diff --git a/countingworkspace/countingworkspace.py b/countingworkspace/countingworkspace.py index 8828247..648cf87 100644 --- a/countingworkspace/countingworkspace.py +++ b/countingworkspace/countingworkspace.py @@ -1,14 +1,15 @@ import ROOT import numpy as np import logging +import string from itertools import product from . import utils logging.basicConfig(level=logging.INFO) def string_range(n): - if type(n) is not int or n < 0: - raise ValueError("parameters should be a non-negative integer") + if not np.issubdtype(type(n), np.integer) or n < 0: + raise ValueError("parameter %s of type %s should be a non-negative integer" % (n, type(n))) return [str(nn) for nn in range(n)] @@ -36,41 +37,101 @@ def create_observed_number_of_events(ws, bins_cat, expression='nobs_cat{cat}', n ws.defineSet('all_obs', all_obs) -def create_variables(ws, expression, bins=None, values=None, ranges=None): +def create_scalar(ws, expression, value=None, ranges=None): is_formula = ':' in expression - if type(bins) is int: - bins = string_range(bins) - - if is_formula: - if values is not None: - raise ValueError('cannot specify values for formula %s' % expression) - if bins is None: - ws.factory(expression) + if ranges is not None and len(ranges) != 2: + raise ValueError('size of ranges must be 2') + if not is_formula and value is None: + raise ValueError('you should specify a value for expression %s' % expression) + if is_formula and ranges is not None: + raise ValueError('cannot specify range for formula in expression %s' % expression) + if not is_formula: + if ranges is None: + return ws.factory('{expression}[{value}]'.format(expression=expression, value=value)) else: - for b in bins: - ws.factory(expression.format(index0=b)) + return ws.factory('{expression}[{value},{down},{up}]'.format(expression=expression, value=value, down=ranges[0], up=ranges[1])) else: - if bins is None and values is None: - raise ValueError('need to specify bins and/or values') - if values is None: - values = np.zeros(len(bins)) + if value is not None: + return ws.factory(expression.format(value=value)) + else: + return ws.factory(expression) + + +def create_variables(ws, expression, nbins=None, bins=None, values=None, ranges=None, index_names=None): + + if nbins is not None: + nbins = np.atleast_1d(nbins) + + if bins is not None: + if type(bins[0]) != list and type(bins[0]) != tuple: + bins = [bins] + + if values is not None: values = np.atleast_1d(values) - if bins is None: - bins = string_range(len(values)) - if ranges is None: - ranges = None, None - ranges = np.asarray(ranges) - if ranges.shape == (2, ): - ranges = ((ranges[0], ranges[1]),) * len(bins) + if ranges is not None: + ranges = np.atleast_1d(ranges) + + if np.iterable(values) and nbins is None: + nbins = np.shape(values) + + if bins is not None and nbins is None: + nbins = [len(b) for b in bins] - for b, value, (min_range, max_range) in zip(bins, values, ranges): - if min_range is None and max_range is None: - ws.factory((expression + '[{value}]').format(index0=b, value=value)) - else: - ws.factory((expression + '[{value}, {m}, {M}]').format(index0=b, value=value, - m=min_range, M=max_range)) + if nbins is not None and bins is None: + bins = [string_range(nb) for nb in nbins] + + if nbins is not None and bins is not None: + if [len(b) for b in bins] != list(nbins): + raise ValueError('nbins=%s and bins=%s does not match' % (nbins, bins)) + + if nbins is None or nbins == (1, ): + return create_scalar(ws, expression, None if values is None else values[0], ranges) + + if values is not None and values.shape != nbins: + raise ValueError('values has wrong shape, should be %s, it is %s' % (nbins, values.shape)) + + index_names = np.atleast_1d(index_names) + logging.debug('after normalizations inputs are: expression=%s, nbins=%s, bins=%s, values=%s, ranges=%s, index_names=%s', + expression, nbins, bins, values, ranges, index_names) + + if np.sum([b != 1 for b in nbins]) != np.sum([idx is not None for idx in index_names]): + logging.debug('trying to determine indexes in expression %s', expression) + possible_indexes = set([tup[1] for tup in string.Formatter().parse(expression) if tup[1] is not None]) + if values is not None: + if 'value' in possible_indexes: + possible_indexes.remove('value') + if len(possible_indexes) == 0: + raise ValueError('there is no index in expression %s' % expression) + if len(possible_indexes) != 1: + raise ValueError('cannot determine which index to use in expression %s, possible indexes: %s' % (expression, possible_indexes)) + index_names = list(possible_indexes) + logging.debug('index_names = %s', index_names) + + + if len(nbins) == 1: + results = [] + if values is None: + for b in bins[0]: + results.append(create_variables(ws, expression.format(**{index_names[0]:b}))) + else: + for v, b in zip(values, bins[0]): + results.append(create_variables(ws, expression.format(**{index_names[0]:b, 'value':'{value}'}), values=v, ranges=ranges)) + return results + else: + if len(index_names) != len(nbins): + raise ValueError('cannot find all the index') + results = [] + if values is None: + for ib, b in enumerate(bins[0]): + logging.debug('calling with expression=%s, bins=%s', expression.replace('{%s}' % index_names[0], b), bins[1:]) + results.append(create_variables(ws, expression.replace('{%s}' % index_names[0], b), bins=bins[1:])) + else: + for ib, b in enumerate(bins[0]): + logging.debug('calling with expression=%s, values=%s, bins=%s', expression.replace('{%s}' % index_names[0], b), values[ib, :], bins[1:]) + results.append(create_variables(ws, expression.replace('{%s}' % index_names[0], b), values=values[ib, :], bins=bins[1:])) + return results def create_efficiencies(ws, efficiencies, expression='eff_cat{cat}_proc{proc}', @@ -92,7 +153,10 @@ def create_efficiencies(ws, efficiencies, expression='eff_cat{cat}_proc{proc}', def create_expected_number_of_signal_events(ws, bins_cat, bins_proc, - expression_nexp='prod:nexp_signal_cat{cat}_proc{proc}(nsignal_gen_proc{proc}, eff_cat{cat}_proc{proc})'): + expression_nsignal_gen='nsignal_gen_proc{proc}_with_sys', + expression_efficiency='eff_cat{cat}_proc{proc}', + expression_nexp='nexp_signal_cat{cat}_proc{proc}'): + expression = 'prod:%s(%s, %s)' % (expression_nexp, expression_nsignal_gen, expression_efficiency) if type(bins_cat) is int: bins_cat = string_range(bins_cat) if type(bins_proc) is int: @@ -102,7 +166,7 @@ def create_expected_number_of_signal_events(ws, bins_cat, bins_proc, all_expected = ROOT.RooArgSet() for cat, proc in product(bins_cat, bins_proc): # expected events for given category and process - all_expected.add(ws.factory(expression_nexp.format(cat=cat, proc=proc))) + all_expected.add(ws.factory(expression.format(cat=cat, proc=proc))) all_expected.setName('all_expected') ws.defineSet('all_signal_expected', all_expected) @@ -169,10 +233,15 @@ def create_workspace(categories, processes, nsignal_gen=None, efficiencies=None, nexpected_bkg_cat=None, + systematics_nsignal_gen=None, + systematic_efficiencies=None, expression_nobs_cat='nobs_cat{cat}', + expression_nsignal_gen='nsignal_gen_proc{proc}', + expression_nsignal_gen_with_sys='nsignal_gen_proc{proc}_with_sys', expression_efficiency='eff_cat{cat}_proc{proc}', - expression_nsignal_gen='nsignal_gen_proc{index0}', - expression_nexpected_bkg_cat='nexp_bkg_cat{index0}', + expression_efficiency_with_sys='eff_cat{cat}_proc{proc}_with_sys', + expression_nexpected_bkg_cat='nexp_bkg_cat{cat}', + name_constrain='constrain_sys{sysname}', ws=None): if type(categories) is int: categories = string_range(categories) @@ -183,26 +252,85 @@ def create_workspace(categories, processes, nproc = len(processes) ncat = len(categories) + sysnames = set() efficiencies = np.asarray(efficiencies) if efficiencies.shape != (len(categories), len(processes)): raise ValueError('shape of efficiencies should match (ncategories, nprocess) = ()%d, %d)' % (ncat, nproc)) ws = ws or ROOT.RooWorkspace() + all_nuisances = ROOT.RooArgSet() create_observed_number_of_events(ws, categories, expression=expression_nobs_cat) create_efficiencies(ws, efficiencies, expression=expression_efficiency, bins_proc=processes, bins_cat=categories) + if systematic_efficiencies is None: + expression_efficiency_with_sys = expression_efficiency + else: + for sys_info in systematic_efficiencies: + sysname = sys_info['name'] + if sysname not in sysnames: + create_variables(ws, 'theta_{sysname}'.format(sysname=sysname), values=0, ranges=(-5, 5)) + all_nuisances.add(ws.var('theta_{sysname}'.format(sysname=sysname))) + sysnames.add(sysname) + sysvalues = np.asarray(sys_info['values']) + if sysvalues.shape != (len(categories), len(processes)): + raise ValueError('shape of efficiency systematic %s should match (ncategories, nprocess) = (%d, %d))' % (sysname, ncat, nproc)) + expression_response = 'expr:response_sys{sysname}_efficiency_cat{{cat}}_proc{{proc}}("1 + @0 * @1", sigma_{sysname}_efficiency_cat{{cat}}_proc{{proc}}[{{value}}], theta_{sysname})'.format(sysname=sysname) + create_variables(ws, expression_response, bins=(categories, processes), values=sysvalues, index_names=('cat', 'proc')) + sysnames_joint = ','.join(['response_sys{sysname}_efficiency_cat{{cat}}_proc{{proc}}'.format(sysname=sys_info['name']) + for sys_info in systematic_efficiencies]) + create_variables(ws, 'prod:%s(%s, %s)' % (expression_efficiency_with_sys, expression_efficiency, sysnames_joint), + bins=(categories, processes), index_names=('cat', 'proc')) # create the number of signal event at true level, only if they are not all present - if not all(ws.obj(expression_nsignal_gen.format(index0=icat)) for icat in range(nproc)): - create_variables(ws, expression_nsignal_gen, processes, nsignal_gen, (-10000, 50000)) - create_variables(ws, expression_nexpected_bkg_cat, categories, nexpected_bkg_cat) - create_expected_number_of_signal_events(ws, categories, processes) - create_model(ws, categories, processes) + if not all(ws.obj(expression_nsignal_gen.format(proc=proc)) for proc in processes): + create_variables(ws, expression_nsignal_gen, bins=processes, values=nsignal_gen, ranges=(-10000, 50000)) + if systematics_nsignal_gen is None: + expression_nsignal_gen_with_sys = expression_nsignal_gen + else: + for sys_info in systematics_nsignal_gen: + sysname = sys_info['name'] + if sysname not in sysnames: + create_variables(ws, 'theta_{sysname}'.format(sysname=sysname), values=0, ranges=(-5, 5)) + all_nuisances.add(ws.var('theta_{sysname}'.format(sysname=sysname))) + sysnames.add(sysname) + sysvalues = sys_info['values'] + if len(sysvalues) != nproc: + raise ValueError('size of values for systematics {sysname} is different from the number of processes ({nproc})'.format(sysname=sysname, ncat=nproc)) + expression_response = 'expr:response_sys{sysname}_nprod_proc{{proc}}("1 + @0 * @1", sigma_{sysname}_nprod_proc{{proc}}[{{value}}], theta_{sysname})'.format(sysname=sysname) + create_variables(ws, expression_response, bins=processes, values=sysvalues) + sysnames_joint = ','.join(['response_sys{sysname}_nprod_proc{{proc}}'.format(sysname=sys_info['name']) + for sys_info in systematics_nsignal_gen]) + create_variables(ws, 'prod:%s(%s, %s)' % (expression_nsignal_gen_with_sys, expression_nsignal_gen, sysnames_joint), bins=processes) + create_variables(ws, expression_nexpected_bkg_cat, bins=categories, values=nexpected_bkg_cat) + create_expected_number_of_signal_events(ws, categories, processes, + expression_efficiency=expression_efficiency_with_sys, + expression_nsignal_gen=expression_nsignal_gen_with_sys) + + all_constrains = ROOT.RooArgSet() + all_globals = ROOT.RooArgSet() + for sysname in sysnames: + global_obs = ws.factory('global_{sysname}[0, -5, 5]'.format(sysname=sysname)) + global_obs.setConstant() + nc = name_constrain.format(sysname=sysname) + _ = ws.factory('RooGaussian:{name}(global_{sysname}, theta_{sysname}, 1)'.format(sysname=sysname, name=nc)) + all_constrains.add(_) + all_globals.add(global_obs) + ws.defineSet('constrains', all_constrains) + ws.factory('PROD:prod_constrains(%s)' % ','.join([v.GetName() for v in utils.iter_collection(all_constrains)])) + + if sysnames: + create_model(ws, categories, processes, expression_model='model_nosys') + ws.factory('PROD:model(model_nosys, prod_constrains)') + else: + create_model(ws, categories, processes) ws.saveSnapshot('initial', ws.allVars()) model_config = ROOT.RooStats.ModelConfig('ModelConfig', ws) model_config.SetPdf('model') model_config.SetObservables(ws.set('all_obs')) + model_config.SetNuisanceParameters(all_nuisances) + model_config.SetGlobalObservables(all_globals) poi = utils.get_free_variables(ws) + poi.remove(all_nuisances) model_config.SetParametersOfInterest(poi) getattr(ws, 'import')(model_config) diff --git a/countingworkspace/examples.py b/countingworkspace/examples.py index ef84354..d21ec8a 100644 --- a/countingworkspace/examples.py +++ b/countingworkspace/examples.py @@ -75,3 +75,5 @@ ) EFFICIENCIES = EFFICIENCIES_CAT_PRODUCTIONMODE * 0.9 + +NAMES_PROC = ['ggF', 'VBF', 'VH', 'TOP'] \ No newline at end of file diff --git a/examples/Example4.ipynb b/examples/Example4.ipynb new file mode 100644 index 0000000..a5a01f9 --- /dev/null +++ b/examples/Example4.ipynb @@ -0,0 +1,1125 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example 4\n", + "\n", + "Create a workspace without systematics and with signal strengths interpretation of the number of fitted events. Add some systematics." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + "import numpy as np\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. Let implement the k-framework, in the easiest version with $k_F$ and $k_V$:\n", + "\n", + "$$\\vec T = L \\vec \\mu_{i\\to H\\to\\gamma\\gamma} \\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 functions of $k_F$ and $k_V$:\n", + "\n", + "$$\\mu_{i\\to H\\to\\gamma\\gamma} = k_i^2\\frac{k_{\\gamma\\gamma}^2}{k_H^2}$$\n", + "\n", + "All the $k_i^2$, $k_{\\gamma\\gamma}^2$ and $k_H^2$ are functions of $k_V$ and $k_F$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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": 4, + "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": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RooFormulaVar::mu_ggF[ actualVars=(k_ggF_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.99\n", + "RooFormulaVar::mu_VBF[ actualVars=(k_VBF_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.99\n", + "RooFormulaVar::mu_VH[ actualVars=(k_VH_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.99\n", + "RooFormulaVar::mu_TOP[ actualVars=(k_TOP_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.99\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", + "ws.factory('kF[1, 0, 2]')\n", + "ws.factory('kV[1, 0, 2]')\n", + "ws.factory('expr:k_ggF_prod(\"@0 *@0\", kF)')\n", + "ws.factory('expr:k_VBF_prod(\"@0 * @0\", kV)')\n", + "ws.factory('expr:k_VH_prod(\"@0 * @0\", kV)')\n", + "ws.factory('expr:k_TOP_prod(\"@0 * @0\", kF)')\n", + "ws.factory('expr:k_yy_decay(\"1.59 * @0 * @0 + 0.07 * @1 * @1 - 0.67 * @0 * @1\", kV, kF)')\n", + "ws.factory('expr:k_higgs(\"0.75 * @0 * @0 + 0.25 * @1 * @1\", kF, kV)')\n", + "mus = create_variables(ws, 'expr:mu_{proc}(\"@0 * @1 / @2\", k_{proc}_prod, k_yy_decay, k_higgs)', bins=NAMES_PROC)\n", + "\n", + "# TODO: why they are not 1?\n", + "\n", + "for mu in mus:\n", + " mu.Print()\n", + "\n", + "# we have all the ingredients to define the parametrization" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# these are just random number as example\n", + "\n", + "# 5% systematics on all the generated number of events due to luminosity\n", + "systematics_nsignal_gen_lumi = np.ones(NPROCESS) * 0.05\n", + "\n", + "# 6% systematics from btagging on ttH categories (last seven)\n", + "systematics_efficiency_btagging = np.zeros_like(EFFICIENCIES)\n", + "systematics_efficiency_btagging[-7:, :] = 0.06\n", + "\n", + "# 2% systematics from identification\n", + "systematics_efficiency_id = np.ones_like(EFFICIENCIES) * 0.02" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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 = 13621.8\n", + " 2) RooAddition:: nexp_cat1 = 47096.2\n", + " 3) RooAddition:: nexp_cat2 = 19554\n", + " 4) RooAddition:: nexp_cat3 = 7193.41\n", + " 5) RooAddition:: nexp_cat4 = 701.448\n", + " 6) RooAddition:: nexp_cat5 = 96.2259\n", + " 7) RooAddition:: nexp_cat6 = 7860.49\n", + " 8) RooAddition:: nexp_cat7 = 4236.03\n", + " 9) RooAddition:: nexp_cat8 = 746.478\n", + " 10) RooAddition:: nexp_cat9 = 74.7314\n", + " 11) RooAddition:: nexp_cat10 = 316.875\n", + " 12) RooAddition:: nexp_cat11 = 61.1013\n", + " 13) RooAddition:: nexp_cat12 = 723.948\n", + " 14) RooAddition:: nexp_cat13 = 360.811\n", + " 15) RooAddition:: nexp_cat14 = 500.52\n", + " 16) RooAddition:: nexp_cat15 = 132.625\n", + " 17) RooAddition:: nexp_cat16 = 647.711\n", + " 18) RooAddition:: nexp_cat17 = 11.0828\n", + " 19) RooAddition:: nexp_cat18 = 8.91902\n", + " 20) RooAddition:: nexp_cat19 = 106.072\n", + " 21) RooAddition:: nexp_cat20 = 8.04832\n", + " 22) RooAddition:: nexp_cat21 = 4.22619\n", + " 23) RooAddition:: nexp_cat22 = 61.1529\n", + " 24) RooAddition:: nexp_cat23 = 39.6653\n", + " 25) RooAddition:: nexp_cat24 = 12.3248\n", + " 26) RooAddition:: nexp_cat25 = 6.13154\n", + " 27) RooAddition:: nexp_cat26 = 5.8404\n", + " 28) RooAddition:: nexp_cat27 = 7.45624\n", + " 29) RooAddition:: nexp_cat28 = 7.04041\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}, lumi, xsec_{proc})',\n", + " # these are systematics on the (mu * L * xsection) expression\n", + " systematics_nsignal_gen=[{'name': 'lumi', 'values': systematics_nsignal_gen_lumi}],\n", + " # these are on each efficiencies\n", + " systematic_efficiencies=[{'name': 'btag', 'values': systematics_efficiency_btagging},\n", + " {'name': 'id', 'values': systematics_efficiency_id}],\n", + " ws=ws)\n", + "\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": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataStore CountingAsimovData0 (CountingAsimovData0)\n", + " Contains 1 entries\n", + " Observables: \n", + " 1) nobs_cat0 = 13621.8 L(0 - 100000) \"nobs_cat0\"\n", + " 2) nobs_cat1 = 47096.2 L(0 - 100000) \"nobs_cat1\"\n", + " 3) nobs_cat2 = 19554 L(0 - 100000) \"nobs_cat2\"\n", + " 4) nobs_cat3 = 7193.41 L(0 - 100000) \"nobs_cat3\"\n", + " 5) nobs_cat4 = 701.448 L(0 - 100000) \"nobs_cat4\"\n", + " 6) nobs_cat5 = 96.2259 L(0 - 100000) \"nobs_cat5\"\n", + " 7) nobs_cat6 = 7860.49 L(0 - 100000) \"nobs_cat6\"\n", + " 8) nobs_cat7 = 4236.03 L(0 - 100000) \"nobs_cat7\"\n", + " 9) nobs_cat8 = 746.478 L(0 - 100000) \"nobs_cat8\"\n", + " 10) nobs_cat9 = 74.7314 L(0 - 100000) \"nobs_cat9\"\n", + " 11) nobs_cat10 = 316.875 L(0 - 100000) \"nobs_cat10\"\n", + " 12) nobs_cat11 = 61.1013 L(0 - 100000) \"nobs_cat11\"\n", + " 13) nobs_cat12 = 723.948 L(0 - 100000) \"nobs_cat12\"\n", + " 14) nobs_cat13 = 360.811 L(0 - 100000) \"nobs_cat13\"\n", + " 15) nobs_cat14 = 500.52 L(0 - 100000) \"nobs_cat14\"\n", + " 16) nobs_cat15 = 132.625 L(0 - 100000) \"nobs_cat15\"\n", + " 17) nobs_cat16 = 647.711 L(0 - 100000) \"nobs_cat16\"\n", + " 18) nobs_cat17 = 11.0828 L(0 - 100000) \"nobs_cat17\"\n", + " 19) nobs_cat18 = 8.91902 L(0 - 100000) \"nobs_cat18\"\n", + " 20) nobs_cat19 = 106.072 L(0 - 100000) \"nobs_cat19\"\n", + " 21) nobs_cat20 = 8.04832 L(0 - 100000) \"nobs_cat20\"\n", + " 22) nobs_cat21 = 4.22619 L(0 - 100000) \"nobs_cat21\"\n", + " 23) nobs_cat22 = 61.1529 L(0 - 100000) \"nobs_cat22\"\n", + " 24) nobs_cat23 = 39.6653 L(0 - 100000) \"nobs_cat23\"\n", + " 25) nobs_cat24 = 12.3248 L(0 - 100000) \"nobs_cat24\"\n", + " 26) nobs_cat25 = 6.13154 L(0 - 100000) \"nobs_cat25\"\n", + " 27) nobs_cat26 = 5.8404 L(0 - 100000) \"nobs_cat26\"\n", + " 28) nobs_cat27 = 7.45624 L(0 - 100000) \"nobs_cat27\"\n", + " 29) nobs_cat28 = 7.04041 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": 9, + "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 kF 1.00000e+00 2.00000e-01 0.00000e+00 2.00000e+00\n", + " 2 kV 1.00000e+00 2.00000e-01 0.00000e+00 2.00000e+00\n", + " 3 theta_btag 0.00000e+00 1.00000e+00 -5.00000e+00 5.00000e+00\n", + " 4 theta_id 0.00000e+00 1.00000e+00 -5.00000e+00 5.00000e+00\n", + " 5 theta_lumi 0.00000e+00 1.00000e+00 -5.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 2500 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=104 FROM MIGRAD STATUS=INITIATE 20 CALLS 21 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 kF 1.00000e+00 2.00000e-01 2.01358e-01 -3.39205e-05\n", + " 2 kV 1.00000e+00 2.00000e-01 2.01358e-01 2.44083e-05\n", + " 3 theta_btag 0.00000e+00 1.00000e+00 2.01358e-01 -1.06265e-07\n", + " 4 theta_id 0.00000e+00 1.00000e+00 2.01358e-01 -2.85424e-09\n", + " 5 theta_lumi 0.00000e+00 1.00000e+00 2.01358e-01 -2.14542e-07\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=104 FROM MIGRAD STATUS=CONVERGED 72 CALLS 73 TOTAL\n", + " EDM=2.02496e-11 STRATEGY= 1 ERROR MATRIX ACCURATE \n", + " EXT PARAMETER STEP FIRST \n", + " NO. NAME VALUE ERROR SIZE DERIVATIVE \n", + " 1 kF 1.00000e+00 1.94041e-01 8.25698e-04 3.79815e-05\n", + " 2 kV 1.00000e+00 6.03797e-02 2.30570e-04 -1.21385e-04\n", + " 3 theta_btag 2.04294e-08 9.76128e-01 1.38418e-03 -2.61414e-07\n", + " 4 theta_id 5.38859e-10 9.93399e-01 1.37168e-03 -4.10174e-06\n", + " 5 theta_lumi 3.12965e-08 9.93726e-01 1.20573e-03 -9.96315e-06\n", + " ERR DEF= 0.5\n", + " EXTERNAL ERROR MATRIX. NDIM= 25 NPAR= 5 ERR DEF=0.5\n", + " 3.813e-02 9.055e-03 -8.488e-03 -1.005e-02 -2.512e-02 \n", + " 9.055e-03 3.650e-03 -3.355e-03 -1.002e-02 -2.506e-02 \n", + " -8.488e-03 -3.355e-03 9.652e-01 1.610e-05 4.257e-05 \n", + " -1.005e-02 -1.002e-02 1.610e-05 1.000e+00 2.370e-04 \n", + " -2.512e-02 -2.506e-02 4.257e-05 2.370e-04 1.001e+00 \n", + " PARAMETER CORRELATION COEFFICIENTS \n", + " NO. GLOBAL 1 2 3 4 5\n", + " 1 0.80076 1.000 0.768 -0.044 -0.051 -0.129\n", + " 2 0.84126 0.768 1.000 -0.057 -0.166 -0.415\n", + " 3 0.06383 -0.044 -0.057 1.000 0.000 0.000\n", + " 4 0.23694 -0.051 -0.166 0.000 1.000 0.000\n", + " 5 0.52075 -0.129 -0.415 0.000 0.000 1.000\n", + " **********\n", + " ** 7 **SET ERR 0.5\n", + " **********\n", + " **********\n", + " ** 8 **SET PRINT 1\n", + " **********\n", + " **********\n", + " ** 9 **HESSE 2500\n", + " **********\n", + " COVARIANCE MATRIX CALCULATED SUCCESSFULLY\n", + " FCN=104 FROM HESSE STATUS=OK 35 CALLS 108 TOTAL\n", + " EDM=1.58249e-11 STRATEGY= 1 ERROR MATRIX ACCURATE \n", + " EXT PARAMETER INTERNAL INTERNAL \n", + " NO. NAME VALUE ERROR STEP SIZE VALUE \n", + " 1 kF 1.00000e+00 1.93155e-01 3.30279e-05 4.64106e-07\n", + " 2 kV 1.00000e+00 6.00494e-02 9.22280e-06 -2.60408e-08\n", + " 3 theta_btag 2.04294e-08 9.76114e-01 5.53672e-05 4.08588e-09\n", + " 4 theta_id 5.38859e-10 9.93168e-01 2.74335e-04 1.07772e-10\n", + " 5 theta_lumi 3.12965e-08 9.92456e-01 2.41147e-04 6.25930e-09\n", + " ERR DEF= 0.5\n", + " EXTERNAL ERROR MATRIX. NDIM= 25 NPAR= 5 ERR DEF=0.5\n", + " 3.778e-02 8.941e-03 -8.398e-03 -9.714e-03 -2.425e-02 \n", + " 8.941e-03 3.610e-03 -3.322e-03 -9.896e-03 -2.474e-02 \n", + " -8.398e-03 -3.322e-03 9.652e-01 -9.337e-05 -2.362e-04 \n", + " -9.714e-03 -9.896e-03 -9.337e-05 9.996e-01 -6.976e-04 \n", + " -2.425e-02 -2.474e-02 -2.362e-04 -6.976e-04 9.982e-01 \n", + " PARAMETER CORRELATION COEFFICIENTS \n", + " NO. GLOBAL 1 2 3 4 5\n", + " 1 0.79913 1.000 0.766 -0.044 -0.050 -0.125\n", + " 2 0.83968 0.766 1.000 -0.056 -0.165 -0.412\n", + " 3 0.06361 -0.044 -0.056 1.000 -0.000 -0.000\n", + " 4 0.23613 -0.050 -0.165 -0.000 1.000 -0.001\n", + " 5 0.51897 -0.125 -0.412 -0.000 -0.001 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": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " RooFitResult: minimized FCN value: 104, estimated distance to minimum: 1.58249e-11\n", + " covariance matrix quality: Full, accurate covariance matrix\n", + " Status : MINIMIZE=0 HESSE=0 \n", + "\n", + " Floating Parameter FinalValue +/- Error \n", + " -------------------- --------------------------\n", + " kF 1.0000e+00 +/- 1.93e-01\n", + " kV 1.0000e+00 +/- 6.00e-02\n", + " theta_btag 2.0429e-08 +/- 9.76e-01\n", + " theta_id 5.3886e-10 +/- 9.93e-01\n", + " theta_lumi 3.1296e-08 +/- 9.92e-01\n", + "\n" + ] + } + ], + "source": [ + "# print the results\n", + "fr.Print()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nll = pdf.createNLL(data_asimov)\n", + "h = ws.var('kV').createHistogram('kV vs kF', ROOT.RooFit.Binning(200),\n", + " ROOT.RooFit.YVar(ws.var('kF'), ROOT.RooFit.Binning(200)))\n", + "nll.fillHistogram(h, ROOT.RooArgList(ws.var('kV'), ws.var('kF')))\n", + "\n", + "canvas = ROOT.TCanvas()\n", + "h.Draw('colz')\n", + "h.GetZaxis().SetRangeUser(0, 0.04)\n", + "canvas.Draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RooWorkspace() contents\n", + "\n", + "variables\n", + "---------\n", + "(eff_cat0_procTOP,eff_cat0_procVBF,eff_cat0_procVH,eff_cat0_procggF,eff_cat10_procTOP,eff_cat10_procVBF,eff_cat10_procVH,eff_cat10_procggF,eff_cat11_procTOP,eff_cat11_procVBF,eff_cat11_procVH,eff_cat11_procggF,eff_cat12_procTOP,eff_cat12_procVBF,eff_cat12_procVH,eff_cat12_procggF,eff_cat13_procTOP,eff_cat13_procVBF,eff_cat13_procVH,eff_cat13_procggF,eff_cat14_procTOP,eff_cat14_procVBF,eff_cat14_procVH,eff_cat14_procggF,eff_cat15_procTOP,eff_cat15_procVBF,eff_cat15_procVH,eff_cat15_procggF,eff_cat16_procTOP,eff_cat16_procVBF,eff_cat16_procVH,eff_cat16_procggF,eff_cat17_procTOP,eff_cat17_procVBF,eff_cat17_procVH,eff_cat17_procggF,eff_cat18_procTOP,eff_cat18_procVBF,eff_cat18_procVH,eff_cat18_procggF,eff_cat19_procTOP,eff_cat19_procVBF,eff_cat19_procVH,eff_cat19_procggF,eff_cat1_procTOP,eff_cat1_procVBF,eff_cat1_procVH,eff_cat1_procggF,eff_cat20_procTOP,eff_cat20_procVBF,eff_cat20_procVH,eff_cat20_procggF,eff_cat21_procTOP,eff_cat21_procVBF,eff_cat21_procVH,eff_cat21_procggF,eff_cat22_procTOP,eff_cat22_procVBF,eff_cat22_procVH,eff_cat22_procggF,eff_cat23_procTOP,eff_cat23_procVBF,eff_cat23_procVH,eff_cat23_procggF,eff_cat24_procTOP,eff_cat24_procVBF,eff_cat24_procVH,eff_cat24_procggF,eff_cat25_procTOP,eff_cat25_procVBF,eff_cat25_procVH,eff_cat25_procggF,eff_cat26_procTOP,eff_cat26_procVBF,eff_cat26_procVH,eff_cat26_procggF,eff_cat27_procTOP,eff_cat27_procVBF,eff_cat27_procVH,eff_cat27_procggF,eff_cat28_procTOP,eff_cat28_procVBF,eff_cat28_procVH,eff_cat28_procggF,eff_cat2_procTOP,eff_cat2_procVBF,eff_cat2_procVH,eff_cat2_procggF,eff_cat3_procTOP,eff_cat3_procVBF,eff_cat3_procVH,eff_cat3_procggF,eff_cat4_procTOP,eff_cat4_procVBF,eff_cat4_procVH,eff_cat4_procggF,eff_cat5_procTOP,eff_cat5_procVBF,eff_cat5_procVH,eff_cat5_procggF,eff_cat6_procTOP,eff_cat6_procVBF,eff_cat6_procVH,eff_cat6_procggF,eff_cat7_procTOP,eff_cat7_procVBF,eff_cat7_procVH,eff_cat7_procggF,eff_cat8_procTOP,eff_cat8_procVBF,eff_cat8_procVH,eff_cat8_procggF,eff_cat9_procTOP,eff_cat9_procVBF,eff_cat9_procVH,eff_cat9_procggF,global_btag,global_id,global_lumi,kF,kV,lumi,nexp_bkg_cat0,nexp_bkg_cat1,nexp_bkg_cat10,nexp_bkg_cat11,nexp_bkg_cat12,nexp_bkg_cat13,nexp_bkg_cat14,nexp_bkg_cat15,nexp_bkg_cat16,nexp_bkg_cat17,nexp_bkg_cat18,nexp_bkg_cat19,nexp_bkg_cat2,nexp_bkg_cat20,nexp_bkg_cat21,nexp_bkg_cat22,nexp_bkg_cat23,nexp_bkg_cat24,nexp_bkg_cat25,nexp_bkg_cat26,nexp_bkg_cat27,nexp_bkg_cat28,nexp_bkg_cat3,nexp_bkg_cat4,nexp_bkg_cat5,nexp_bkg_cat6,nexp_bkg_cat7,nexp_bkg_cat8,nexp_bkg_cat9,nobs_cat0,nobs_cat1,nobs_cat10,nobs_cat11,nobs_cat12,nobs_cat13,nobs_cat14,nobs_cat15,nobs_cat16,nobs_cat17,nobs_cat18,nobs_cat19,nobs_cat2,nobs_cat20,nobs_cat21,nobs_cat22,nobs_cat23,nobs_cat24,nobs_cat25,nobs_cat26,nobs_cat27,nobs_cat28,nobs_cat3,nobs_cat4,nobs_cat5,nobs_cat6,nobs_cat7,nobs_cat8,nobs_cat9,sigma_btag_efficiency_cat0_procTOP,sigma_btag_efficiency_cat0_procVBF,sigma_btag_efficiency_cat0_procVH,sigma_btag_efficiency_cat0_procggF,sigma_btag_efficiency_cat10_procTOP,sigma_btag_efficiency_cat10_procVBF,sigma_btag_efficiency_cat10_procVH,sigma_btag_efficiency_cat10_procggF,sigma_btag_efficiency_cat11_procTOP,sigma_btag_efficiency_cat11_procVBF,sigma_btag_efficiency_cat11_procVH,sigma_btag_efficiency_cat11_procggF,sigma_btag_efficiency_cat12_procTOP,sigma_btag_efficiency_cat12_procVBF,sigma_btag_efficiency_cat12_procVH,sigma_btag_efficiency_cat12_procggF,sigma_btag_efficiency_cat13_procTOP,sigma_btag_efficiency_cat13_procVBF,sigma_btag_efficiency_cat13_procVH,sigma_btag_efficiency_cat13_procggF,sigma_btag_efficiency_cat14_procTOP,sigma_btag_efficiency_cat14_procVBF,sigma_btag_efficiency_cat14_procVH,sigma_btag_efficiency_cat14_procggF,sigma_btag_efficiency_cat15_procTOP,sigma_btag_efficiency_cat15_procVBF,sigma_btag_efficiency_cat15_procVH,sigma_btag_efficiency_cat15_procggF,sigma_btag_efficiency_cat16_procTOP,sigma_btag_efficiency_cat16_procVBF,sigma_btag_efficiency_cat16_procVH,sigma_btag_efficiency_cat16_procggF,sigma_btag_efficiency_cat17_procTOP,sigma_btag_efficiency_cat17_procVBF,sigma_btag_efficiency_cat17_procVH,sigma_btag_efficiency_cat17_procggF,sigma_btag_efficiency_cat18_procTOP,sigma_btag_efficiency_cat18_procVBF,sigma_btag_efficiency_cat18_procVH,sigma_btag_efficiency_cat18_procggF,sigma_btag_efficiency_cat19_procTOP,sigma_btag_efficiency_cat19_procVBF,sigma_btag_efficiency_cat19_procVH,sigma_btag_efficiency_cat19_procggF,sigma_btag_efficiency_cat1_procTOP,sigma_btag_efficiency_cat1_procVBF,sigma_btag_efficiency_cat1_procVH,sigma_btag_efficiency_cat1_procggF,sigma_btag_efficiency_cat20_procTOP,sigma_btag_efficiency_cat20_procVBF,sigma_btag_efficiency_cat20_procVH,sigma_btag_efficiency_cat20_procggF,sigma_btag_efficiency_cat21_procTOP,sigma_btag_efficiency_cat21_procVBF,sigma_btag_efficiency_cat21_procVH,sigma_btag_efficiency_cat21_procggF,sigma_btag_efficiency_cat22_procTOP,sigma_btag_efficiency_cat22_procVBF,sigma_btag_efficiency_cat22_procVH,sigma_btag_efficiency_cat22_procggF,sigma_btag_efficiency_cat23_procTOP,sigma_btag_efficiency_cat23_procVBF,sigma_btag_efficiency_cat23_procVH,sigma_btag_efficiency_cat23_procggF,sigma_btag_efficiency_cat24_procTOP,sigma_btag_efficiency_cat24_procVBF,sigma_btag_efficiency_cat24_procVH,sigma_btag_efficiency_cat24_procggF,sigma_btag_efficiency_cat25_procTOP,sigma_btag_efficiency_cat25_procVBF,sigma_btag_efficiency_cat25_procVH,sigma_btag_efficiency_cat25_procggF,sigma_btag_efficiency_cat26_procTOP,sigma_btag_efficiency_cat26_procVBF,sigma_btag_efficiency_cat26_procVH,sigma_btag_efficiency_cat26_procggF,sigma_btag_efficiency_cat27_procTOP,sigma_btag_efficiency_cat27_procVBF,sigma_btag_efficiency_cat27_procVH,sigma_btag_efficiency_cat27_procggF,sigma_btag_efficiency_cat28_procTOP,sigma_btag_efficiency_cat28_procVBF,sigma_btag_efficiency_cat28_procVH,sigma_btag_efficiency_cat28_procggF,sigma_btag_efficiency_cat2_procTOP,sigma_btag_efficiency_cat2_procVBF,sigma_btag_efficiency_cat2_procVH,sigma_btag_efficiency_cat2_procggF,sigma_btag_efficiency_cat3_procTOP,sigma_btag_efficiency_cat3_procVBF,sigma_btag_efficiency_cat3_procVH,sigma_btag_efficiency_cat3_procggF,sigma_btag_efficiency_cat4_procTOP,sigma_btag_efficiency_cat4_procVBF,sigma_btag_efficiency_cat4_procVH,sigma_btag_efficiency_cat4_procggF,sigma_btag_efficiency_cat5_procTOP,sigma_btag_efficiency_cat5_procVBF,sigma_btag_efficiency_cat5_procVH,sigma_btag_efficiency_cat5_procggF,sigma_btag_efficiency_cat6_procTOP,sigma_btag_efficiency_cat6_procVBF,sigma_btag_efficiency_cat6_procVH,sigma_btag_efficiency_cat6_procggF,sigma_btag_efficiency_cat7_procTOP,sigma_btag_efficiency_cat7_procVBF,sigma_btag_efficiency_cat7_procVH,sigma_btag_efficiency_cat7_procggF,sigma_btag_efficiency_cat8_procTOP,sigma_btag_efficiency_cat8_procVBF,sigma_btag_efficiency_cat8_procVH,sigma_btag_efficiency_cat8_procggF,sigma_btag_efficiency_cat9_procTOP,sigma_btag_efficiency_cat9_procVBF,sigma_btag_efficiency_cat9_procVH,sigma_btag_efficiency_cat9_procggF,sigma_id_efficiency_cat0_procTOP,sigma_id_efficiency_cat0_procVBF,sigma_id_efficiency_cat0_procVH,sigma_id_efficiency_cat0_procggF,sigma_id_efficiency_cat10_procTOP,sigma_id_efficiency_cat10_procVBF,sigma_id_efficiency_cat10_procVH,sigma_id_efficiency_cat10_procggF,sigma_id_efficiency_cat11_procTOP,sigma_id_efficiency_cat11_procVBF,sigma_id_efficiency_cat11_procVH,sigma_id_efficiency_cat11_procggF,sigma_id_efficiency_cat12_procTOP,sigma_id_efficiency_cat12_procVBF,sigma_id_efficiency_cat12_procVH,sigma_id_efficiency_cat12_procggF,sigma_id_efficiency_cat13_procTOP,sigma_id_efficiency_cat13_procVBF,sigma_id_efficiency_cat13_procVH,sigma_id_efficiency_cat13_procggF,sigma_id_efficiency_cat14_procTOP,sigma_id_efficiency_cat14_procVBF,sigma_id_efficiency_cat14_procVH,sigma_id_efficiency_cat14_procggF,sigma_id_efficiency_cat15_procTOP,sigma_id_efficiency_cat15_procVBF,sigma_id_efficiency_cat15_procVH,sigma_id_efficiency_cat15_procggF,sigma_id_efficiency_cat16_procTOP,sigma_id_efficiency_cat16_procVBF,sigma_id_efficiency_cat16_procVH,sigma_id_efficiency_cat16_procggF,sigma_id_efficiency_cat17_procTOP,sigma_id_efficiency_cat17_procVBF,sigma_id_efficiency_cat17_procVH,sigma_id_efficiency_cat17_procggF,sigma_id_efficiency_cat18_procTOP,sigma_id_efficiency_cat18_procVBF,sigma_id_efficiency_cat18_procVH,sigma_id_efficiency_cat18_procggF,sigma_id_efficiency_cat19_procTOP,sigma_id_efficiency_cat19_procVBF,sigma_id_efficiency_cat19_procVH,sigma_id_efficiency_cat19_procggF,sigma_id_efficiency_cat1_procTOP,sigma_id_efficiency_cat1_procVBF,sigma_id_efficiency_cat1_procVH,sigma_id_efficiency_cat1_procggF,sigma_id_efficiency_cat20_procTOP,sigma_id_efficiency_cat20_procVBF,sigma_id_efficiency_cat20_procVH,sigma_id_efficiency_cat20_procggF,sigma_id_efficiency_cat21_procTOP,sigma_id_efficiency_cat21_procVBF,sigma_id_efficiency_cat21_procVH,sigma_id_efficiency_cat21_procggF,sigma_id_efficiency_cat22_procTOP,sigma_id_efficiency_cat22_procVBF,sigma_id_efficiency_cat22_procVH,sigma_id_efficiency_cat22_procggF,sigma_id_efficiency_cat23_procTOP,sigma_id_efficiency_cat23_procVBF,sigma_id_efficiency_cat23_procVH,sigma_id_efficiency_cat23_procggF,sigma_id_efficiency_cat24_procTOP,sigma_id_efficiency_cat24_procVBF,sigma_id_efficiency_cat24_procVH,sigma_id_efficiency_cat24_procggF,sigma_id_efficiency_cat25_procTOP,sigma_id_efficiency_cat25_procVBF,sigma_id_efficiency_cat25_procVH,sigma_id_efficiency_cat25_procggF,sigma_id_efficiency_cat26_procTOP,sigma_id_efficiency_cat26_procVBF,sigma_id_efficiency_cat26_procVH,sigma_id_efficiency_cat26_procggF,sigma_id_efficiency_cat27_procTOP,sigma_id_efficiency_cat27_procVBF,sigma_id_efficiency_cat27_procVH,sigma_id_efficiency_cat27_procggF,sigma_id_efficiency_cat28_procTOP,sigma_id_efficiency_cat28_procVBF,sigma_id_efficiency_cat28_procVH,sigma_id_efficiency_cat28_procggF,sigma_id_efficiency_cat2_procTOP,sigma_id_efficiency_cat2_procVBF,sigma_id_efficiency_cat2_procVH,sigma_id_efficiency_cat2_procggF,sigma_id_efficiency_cat3_procTOP,sigma_id_efficiency_cat3_procVBF,sigma_id_efficiency_cat3_procVH,sigma_id_efficiency_cat3_procggF,sigma_id_efficiency_cat4_procTOP,sigma_id_efficiency_cat4_procVBF,sigma_id_efficiency_cat4_procVH,sigma_id_efficiency_cat4_procggF,sigma_id_efficiency_cat5_procTOP,sigma_id_efficiency_cat5_procVBF,sigma_id_efficiency_cat5_procVH,sigma_id_efficiency_cat5_procggF,sigma_id_efficiency_cat6_procTOP,sigma_id_efficiency_cat6_procVBF,sigma_id_efficiency_cat6_procVH,sigma_id_efficiency_cat6_procggF,sigma_id_efficiency_cat7_procTOP,sigma_id_efficiency_cat7_procVBF,sigma_id_efficiency_cat7_procVH,sigma_id_efficiency_cat7_procggF,sigma_id_efficiency_cat8_procTOP,sigma_id_efficiency_cat8_procVBF,sigma_id_efficiency_cat8_procVH,sigma_id_efficiency_cat8_procggF,sigma_id_efficiency_cat9_procTOP,sigma_id_efficiency_cat9_procVBF,sigma_id_efficiency_cat9_procVH,sigma_id_efficiency_cat9_procggF,sigma_lumi_nprod_procTOP,sigma_lumi_nprod_procVBF,sigma_lumi_nprod_procVH,sigma_lumi_nprod_procggF,theta_btag,theta_id,theta_lumi,xsec_TOP,xsec_VBF,xsec_VH,xsec_ggF)\n", + "\n", + "p.d.f.s\n", + "-------\n", + "RooGaussian::constrain_sysbtag[ x=global_btag mean=theta_btag sigma=1 ] = 1/2.50663\n", + "RooGaussian::constrain_sysid[ x=global_id mean=theta_id sigma=1 ] = 1/2.50663\n", + "RooGaussian::constrain_syslumi[ x=global_lumi mean=theta_lumi sigma=1 ] = 1/2.50663\n", + "RooProdPdf::model[ model_nosys * prod_constrains ] = 1.07268e-44\n", + "RooPoisson::model_cat0[ x=nobs_cat0 mean=nexp_cat0 ] = 0.00341815\n", + "RooPoisson::model_cat1[ x=nobs_cat1 mean=nexp_cat1 ] = 0.0018383\n", + "RooPoisson::model_cat10[ x=nobs_cat10 mean=nexp_cat10 ] = 0.0224054\n", + "RooPoisson::model_cat11[ x=nobs_cat11 mean=nexp_cat11 ] = 0.0509674\n", + "RooPoisson::model_cat12[ x=nobs_cat12 mean=nexp_cat12 ] = 0.0148254\n", + "RooPoisson::model_cat13[ x=nobs_cat13 mean=nexp_cat13 ] = 0.0209976\n", + "RooPoisson::model_cat14[ x=nobs_cat14 mean=nexp_cat14 ] = 0.017829\n", + "RooPoisson::model_cat15[ x=nobs_cat15 mean=nexp_cat15 ] = 0.0346197\n", + "RooPoisson::model_cat16[ x=nobs_cat16 mean=nexp_cat16 ] = 0.0156734\n", + "RooPoisson::model_cat17[ x=nobs_cat17 mean=nexp_cat17 ] = 0.118938\n", + "RooPoisson::model_cat18[ x=nobs_cat18 mean=nexp_cat18 ] = 0.132341\n", + "RooPoisson::model_cat19[ x=nobs_cat19 mean=nexp_cat19 ] = 0.0387051\n", + "RooPoisson::model_cat2[ x=nobs_cat2 mean=nexp_cat2 ] = 0.00285292\n", + "RooPoisson::model_cat20[ x=nobs_cat20 mean=nexp_cat20 ] = 0.139176\n", + "RooPoisson::model_cat21[ x=nobs_cat21 mean=nexp_cat21 ] = 0.190278\n", + "RooPoisson::model_cat22[ x=nobs_cat22 mean=nexp_cat22 ] = 0.0509459\n", + "RooPoisson::model_cat23[ x=nobs_cat23 mean=nexp_cat23 ] = 0.063211\n", + "RooPoisson::model_cat24[ x=nobs_cat24 mean=nexp_cat24 ] = 0.112872\n", + "RooPoisson::model_cat25[ x=nobs_cat25 mean=nexp_cat25 ] = 0.158938\n", + "RooPoisson::model_cat26[ x=nobs_cat26 mean=nexp_cat26 ] = 0.162741\n", + "RooPoisson::model_cat27[ x=nobs_cat27 mean=nexp_cat27 ] = 0.144477\n", + "RooPoisson::model_cat28[ x=nobs_cat28 mean=nexp_cat28 ] = 0.148585\n", + "RooPoisson::model_cat3[ x=nobs_cat3 mean=nexp_cat3 ] = 0.00470368\n", + "RooPoisson::model_cat4[ x=nobs_cat4 mean=nexp_cat4 ] = 0.0150612\n", + "RooPoisson::model_cat5[ x=nobs_cat5 mean=nexp_cat5 ] = 0.0406339\n", + "RooPoisson::model_cat6[ x=nobs_cat6 mean=nexp_cat6 ] = 0.00449967\n", + "RooPoisson::model_cat7[ x=nobs_cat7 mean=nexp_cat7 ] = 0.00612945\n", + "RooPoisson::model_cat8[ x=nobs_cat8 mean=nexp_cat8 ] = 0.0146\n", + "RooPoisson::model_cat9[ x=nobs_cat9 mean=nexp_cat9 ] = 0.0460972\n", + "RooProdPdf::model_nosys[ model_cat0 * model_cat1 * model_cat2 * model_cat3 * model_cat4 * model_cat5 * model_cat6 * model_cat7 * model_cat8 * model_cat9 * model_cat10 * model_cat11 * model_cat12 * model_cat13 * model_cat14 * model_cat15 * model_cat16 * model_cat17 * model_cat18 * model_cat19 * model_cat20 * model_cat21 * model_cat22 * model_cat23 * model_cat24 * model_cat25 * model_cat26 * model_cat27 * model_cat28 ] = 1.07268e-44\n", + "RooProdPdf::prod_constrains[ constrain_syslumi * constrain_sysbtag * constrain_sysid ] = 1/1\n", + "\n", + "functions\n", + "--------\n", + "RooProduct::eff_cat0_procTOP_with_sys[ eff_cat0_procTOP * response_sysbtag_efficiency_cat0_procTOP * response_sysid_efficiency_cat0_procTOP ] = 0.000199324\n", + "RooProduct::eff_cat0_procVBF_with_sys[ eff_cat0_procVBF * response_sysbtag_efficiency_cat0_procVBF * response_sysid_efficiency_cat0_procVBF ] = 0.0104605\n", + "RooProduct::eff_cat0_procVH_with_sys[ eff_cat0_procVH * response_sysbtag_efficiency_cat0_procVH * response_sysid_efficiency_cat0_procVH ] = 0.0145412\n", + "RooProduct::eff_cat0_procggF_with_sys[ eff_cat0_procggF * response_sysbtag_efficiency_cat0_procggF * response_sysid_efficiency_cat0_procggF ] = 0.0759656\n", + "RooProduct::eff_cat10_procTOP_with_sys[ eff_cat10_procTOP * response_sysbtag_efficiency_cat10_procTOP * response_sysid_efficiency_cat10_procTOP ] = 0.000579753\n", + "RooProduct::eff_cat10_procVBF_with_sys[ eff_cat10_procVBF * response_sysbtag_efficiency_cat10_procVBF * response_sysid_efficiency_cat10_procVBF ] = 0.0377259\n", + "RooProduct::eff_cat10_procVH_with_sys[ eff_cat10_procVH * response_sysbtag_efficiency_cat10_procVH * response_sysid_efficiency_cat10_procVH ] = 0.000713421\n", + "RooProduct::eff_cat10_procggF_with_sys[ eff_cat10_procggF * response_sysbtag_efficiency_cat10_procggF * response_sysid_efficiency_cat10_procggF ] = 0.00158368\n", + "RooProduct::eff_cat11_procTOP_with_sys[ eff_cat11_procTOP * response_sysbtag_efficiency_cat11_procTOP * response_sysid_efficiency_cat11_procTOP ] = 0.00040142\n", + "RooProduct::eff_cat11_procVBF_with_sys[ eff_cat11_procVBF * response_sysbtag_efficiency_cat11_procVBF * response_sysid_efficiency_cat11_procVBF ] = 0.0359158\n", + "RooProduct::eff_cat11_procVH_with_sys[ eff_cat11_procVH * response_sysbtag_efficiency_cat11_procVH * response_sysid_efficiency_cat11_procVH ] = 0.000152405\n", + "RooProduct::eff_cat11_procggF_with_sys[ eff_cat11_procggF * response_sysbtag_efficiency_cat11_procggF * response_sysid_efficiency_cat11_procggF ] = 0.000411651\n", + "RooProduct::eff_cat12_procTOP_with_sys[ eff_cat12_procTOP * response_sysbtag_efficiency_cat12_procTOP * response_sysid_efficiency_cat12_procTOP ] = 0.00389614\n", + "RooProduct::eff_cat12_procVBF_with_sys[ eff_cat12_procVBF * response_sysbtag_efficiency_cat12_procVBF * response_sysid_efficiency_cat12_procVBF ] = 0.01239\n", + "RooProduct::eff_cat12_procVH_with_sys[ eff_cat12_procVH * response_sysbtag_efficiency_cat12_procVH * response_sysid_efficiency_cat12_procVH ] = 0.00390894\n", + "RooProduct::eff_cat12_procggF_with_sys[ eff_cat12_procggF * response_sysbtag_efficiency_cat12_procggF * response_sysid_efficiency_cat12_procggF ] = 0.00302746\n", + "RooProduct::eff_cat13_procTOP_with_sys[ eff_cat13_procTOP * response_sysbtag_efficiency_cat13_procTOP * response_sysid_efficiency_cat13_procTOP ] = 0.00676058\n", + "RooProduct::eff_cat13_procVBF_with_sys[ eff_cat13_procVBF * response_sysbtag_efficiency_cat13_procVBF * response_sysid_efficiency_cat13_procVBF ] = 0.0304512\n", + "RooProduct::eff_cat13_procVH_with_sys[ eff_cat13_procVH * response_sysbtag_efficiency_cat13_procVH * response_sysid_efficiency_cat13_procVH ] = 0.0030454\n", + "RooProduct::eff_cat13_procggF_with_sys[ eff_cat13_procggF * response_sysbtag_efficiency_cat13_procggF * response_sysid_efficiency_cat13_procggF ] = 0.00246154\n", + "RooProduct::eff_cat14_procTOP_with_sys[ eff_cat14_procTOP * response_sysbtag_efficiency_cat14_procTOP * response_sysid_efficiency_cat14_procTOP ] = 0.00443349\n", + "RooProduct::eff_cat14_procVBF_with_sys[ eff_cat14_procVBF * response_sysbtag_efficiency_cat14_procVBF * response_sysid_efficiency_cat14_procVBF ] = 0.00254553\n", + "RooProduct::eff_cat14_procVH_with_sys[ eff_cat14_procVH * response_sysbtag_efficiency_cat14_procVH * response_sysid_efficiency_cat14_procVH ] = 0.0221037\n", + "RooProduct::eff_cat14_procggF_with_sys[ eff_cat14_procggF * response_sysbtag_efficiency_cat14_procggF * response_sysid_efficiency_cat14_procggF ] = 0.00255636\n", + "RooProduct::eff_cat15_procTOP_with_sys[ eff_cat15_procTOP * response_sysbtag_efficiency_cat15_procTOP * response_sysid_efficiency_cat15_procTOP ] = 0.00291074\n", + "RooProduct::eff_cat15_procVBF_with_sys[ eff_cat15_procVBF * response_sysbtag_efficiency_cat15_procVBF * response_sysid_efficiency_cat15_procVBF ] = 0.00128219\n", + "RooProduct::eff_cat15_procVH_with_sys[ eff_cat15_procVH * response_sysbtag_efficiency_cat15_procVH * response_sysid_efficiency_cat15_procVH ] = 0.026869\n", + "RooProduct::eff_cat15_procggF_with_sys[ eff_cat15_procggF * response_sysbtag_efficiency_cat15_procggF * response_sysid_efficiency_cat15_procggF ] = 0.0014798\n", + "RooProduct::eff_cat16_procTOP_with_sys[ eff_cat16_procTOP * response_sysbtag_efficiency_cat16_procTOP * response_sysid_efficiency_cat16_procTOP ] = 0.0148447\n", + "RooProduct::eff_cat16_procVBF_with_sys[ eff_cat16_procVBF * response_sysbtag_efficiency_cat16_procVBF * response_sysid_efficiency_cat16_procVBF ] = 0.0163704\n", + "RooProduct::eff_cat16_procVH_with_sys[ eff_cat16_procVH * response_sysbtag_efficiency_cat16_procVH * response_sysid_efficiency_cat16_procVH ] = 0.0122852\n", + "RooProduct::eff_cat16_procggF_with_sys[ eff_cat16_procggF * response_sysbtag_efficiency_cat16_procggF * response_sysid_efficiency_cat16_procggF ] = 0.00266558\n", + "RooProduct::eff_cat17_procTOP_with_sys[ eff_cat17_procTOP * response_sysbtag_efficiency_cat17_procTOP * response_sysid_efficiency_cat17_procTOP ] = 7.85191e-05\n", + "RooProduct::eff_cat17_procVBF_with_sys[ eff_cat17_procVBF * response_sysbtag_efficiency_cat17_procVBF * response_sysid_efficiency_cat17_procVBF ] = 2.15495e-05\n", + "RooProduct::eff_cat17_procVH_with_sys[ eff_cat17_procVH * response_sysbtag_efficiency_cat17_procVH * response_sysid_efficiency_cat17_procVH ] = 0.00294284\n", + "RooProduct::eff_cat17_procggF_with_sys[ eff_cat17_procggF * response_sysbtag_efficiency_cat17_procggF * response_sysid_efficiency_cat17_procggF ] = 2.57041e-05\n", + "RooProduct::eff_cat18_procTOP_with_sys[ eff_cat18_procTOP * response_sysbtag_efficiency_cat18_procTOP * response_sysid_efficiency_cat18_procTOP ] = 0.00123834\n", + "RooProduct::eff_cat18_procVBF_with_sys[ eff_cat18_procVBF * response_sysbtag_efficiency_cat18_procVBF * response_sysid_efficiency_cat18_procVBF ] = 5.38736e-06\n", + "RooProduct::eff_cat18_procVH_with_sys[ eff_cat18_procVH * response_sysbtag_efficiency_cat18_procVH * response_sysid_efficiency_cat18_procVH ] = 0.00629712\n", + "RooProduct::eff_cat18_procggF_with_sys[ eff_cat18_procggF * response_sysbtag_efficiency_cat18_procggF * response_sysid_efficiency_cat18_procggF ] = 3.60069e-06\n", + "RooProduct::eff_cat19_procTOP_with_sys[ eff_cat19_procTOP * response_sysbtag_efficiency_cat19_procTOP * response_sysid_efficiency_cat19_procTOP ] = 0.0113398\n", + "RooProduct::eff_cat19_procVBF_with_sys[ eff_cat19_procVBF * response_sysbtag_efficiency_cat19_procVBF * response_sysid_efficiency_cat19_procVBF ] = 0.000169702\n", + "RooProduct::eff_cat19_procVH_with_sys[ eff_cat19_procVH * response_sysbtag_efficiency_cat19_procVH * response_sysid_efficiency_cat19_procVH ] = 0.0241123\n", + "RooProduct::eff_cat19_procggF_with_sys[ eff_cat19_procggF * response_sysbtag_efficiency_cat19_procggF * response_sysid_efficiency_cat19_procggF ] = 0.000140949\n", + "RooProduct::eff_cat1_procTOP_with_sys[ eff_cat1_procTOP * response_sysbtag_efficiency_cat1_procTOP * response_sysid_efficiency_cat1_procTOP ] = 0.000464708\n", + "RooProduct::eff_cat1_procVBF_with_sys[ eff_cat1_procVBF * response_sysbtag_efficiency_cat1_procVBF * response_sysid_efficiency_cat1_procVBF ] = 0.0202726\n", + "RooProduct::eff_cat1_procVH_with_sys[ eff_cat1_procVH * response_sysbtag_efficiency_cat1_procVH * response_sysid_efficiency_cat1_procVH ] = 0.0301054\n", + "RooProduct::eff_cat1_procggF_with_sys[ eff_cat1_procggF * response_sysbtag_efficiency_cat1_procggF * response_sysid_efficiency_cat1_procggF ] = 0.133594\n", + "RooProduct::eff_cat20_procTOP_with_sys[ eff_cat20_procTOP * response_sysbtag_efficiency_cat20_procTOP * response_sysid_efficiency_cat20_procTOP ] = 0.0043889\n", + "RooProduct::eff_cat20_procVBF_with_sys[ eff_cat20_procVBF * response_sysbtag_efficiency_cat20_procVBF * response_sysid_efficiency_cat20_procVBF ] = 2.69368e-06\n", + "RooProduct::eff_cat20_procVH_with_sys[ eff_cat20_procVH * response_sysbtag_efficiency_cat20_procVH * response_sysid_efficiency_cat20_procVH ] = 0.00637653\n", + "RooProduct::eff_cat20_procggF_with_sys[ eff_cat20_procggF * response_sysbtag_efficiency_cat20_procggF * response_sysid_efficiency_cat20_procggF ] = 0\n", + "RooProduct::eff_cat21_procTOP_with_sys[ eff_cat21_procTOP * response_sysbtag_efficiency_cat21_procTOP * response_sysid_efficiency_cat21_procTOP ] = 0.000202334\n", + "RooProduct::eff_cat21_procVBF_with_sys[ eff_cat21_procVBF * response_sysbtag_efficiency_cat21_procVBF * response_sysid_efficiency_cat21_procVBF ] = 0\n", + "RooProduct::eff_cat21_procVH_with_sys[ eff_cat21_procVH * response_sysbtag_efficiency_cat21_procVH * response_sysid_efficiency_cat21_procVH ] = 0.00447888\n", + "RooProduct::eff_cat21_procggF_with_sys[ eff_cat21_procggF * response_sysbtag_efficiency_cat21_procggF * response_sysid_efficiency_cat21_procggF ] = 0\n", + "RooProduct::eff_cat22_procTOP_with_sys[ eff_cat22_procTOP * response_sysbtag_efficiency_cat22_procTOP * response_sysid_efficiency_cat22_procTOP ] = 0.0337407\n", + "RooProduct::eff_cat22_procVBF_with_sys[ eff_cat22_procVBF * response_sysbtag_efficiency_cat22_procVBF * response_sysid_efficiency_cat22_procVBF ] = 0.000344791\n", + "RooProduct::eff_cat22_procVH_with_sys[ eff_cat22_procVH * response_sysbtag_efficiency_cat22_procVH * response_sysid_efficiency_cat22_procVH ] = 0.00250042\n", + "RooProduct::eff_cat22_procggF_with_sys[ eff_cat22_procggF * response_sysbtag_efficiency_cat22_procggF * response_sysid_efficiency_cat22_procggF ] = 0.000185505\n", + "RooProduct::eff_cat23_procTOP_with_sys[ eff_cat23_procTOP * response_sysbtag_efficiency_cat23_procTOP * response_sysid_efficiency_cat23_procTOP ] = 0.0493388\n", + "RooProduct::eff_cat23_procVBF_with_sys[ eff_cat23_procVBF * response_sysbtag_efficiency_cat23_procVBF * response_sysid_efficiency_cat23_procVBF ] = 0.000148152\n", + "RooProduct::eff_cat23_procVH_with_sys[ eff_cat23_procVH * response_sysbtag_efficiency_cat23_procVH * response_sysid_efficiency_cat23_procVH ] = 0.00154299\n", + "RooProduct::eff_cat23_procggF_with_sys[ eff_cat23_procggF * response_sysbtag_efficiency_cat23_procggF * response_sysid_efficiency_cat23_procggF ] = 0.000103138\n", + "RooProduct::eff_cat24_procTOP_with_sys[ eff_cat24_procTOP * response_sysbtag_efficiency_cat24_procTOP * response_sysid_efficiency_cat24_procTOP ] = 0.0348397\n", + "RooProduct::eff_cat24_procVBF_with_sys[ eff_cat24_procVBF * response_sysbtag_efficiency_cat24_procVBF * response_sysid_efficiency_cat24_procVBF ] = 4.30989e-05\n", + "RooProduct::eff_cat24_procVH_with_sys[ eff_cat24_procVH * response_sysbtag_efficiency_cat24_procVH * response_sysid_efficiency_cat24_procVH ] = 0.000513108\n", + "RooProduct::eff_cat24_procggF_with_sys[ eff_cat24_procggF * response_sysbtag_efficiency_cat24_procggF * response_sysid_efficiency_cat24_procggF ] = 3.09359e-05\n", + "RooProduct::eff_cat25_procTOP_with_sys[ eff_cat25_procTOP * response_sysbtag_efficiency_cat25_procTOP * response_sysid_efficiency_cat25_procTOP ] = 0.0424038\n", + "RooProduct::eff_cat25_procVBF_with_sys[ eff_cat25_procVBF * response_sysbtag_efficiency_cat25_procVBF * response_sysid_efficiency_cat25_procVBF ] = 2.33452e-05\n", + "RooProduct::eff_cat25_procVH_with_sys[ eff_cat25_procVH * response_sysbtag_efficiency_cat25_procVH * response_sysid_efficiency_cat25_procVH ] = 0.000355199\n", + "RooProduct::eff_cat25_procggF_with_sys[ eff_cat25_procggF * response_sysbtag_efficiency_cat25_procggF * response_sysid_efficiency_cat25_procggF ] = 1.59987e-05\n", + "RooProduct::eff_cat26_procTOP_with_sys[ eff_cat26_procTOP * response_sysbtag_efficiency_cat26_procTOP * response_sysid_efficiency_cat26_procTOP ] = 0.00979772\n", + "RooProduct::eff_cat26_procVBF_with_sys[ eff_cat26_procVBF * response_sysbtag_efficiency_cat26_procVBF * response_sysid_efficiency_cat26_procVBF ] = 1.79579e-06\n", + "RooProduct::eff_cat26_procVH_with_sys[ eff_cat26_procVH * response_sysbtag_efficiency_cat26_procVH * response_sysid_efficiency_cat26_procVH ] = 0.000280457\n", + "RooProduct::eff_cat26_procggF_with_sys[ eff_cat26_procggF * response_sysbtag_efficiency_cat26_procggF * response_sysid_efficiency_cat26_procggF ] = 9.96932e-07\n", + "RooProduct::eff_cat27_procTOP_with_sys[ eff_cat27_procTOP * response_sysbtag_efficiency_cat27_procTOP * response_sysid_efficiency_cat27_procTOP ] = 0.0235937\n", + "RooProduct::eff_cat27_procVBF_with_sys[ eff_cat27_procVBF * response_sysbtag_efficiency_cat27_procVBF * response_sysid_efficiency_cat27_procVBF ] = 8.97894e-07\n", + "RooProduct::eff_cat27_procVH_with_sys[ eff_cat27_procVH * response_sysbtag_efficiency_cat27_procVH * response_sysid_efficiency_cat27_procVH ] = 0.000205173\n", + "RooProduct::eff_cat27_procggF_with_sys[ eff_cat27_procggF * response_sysbtag_efficiency_cat27_procggF * response_sysid_efficiency_cat27_procggF ] = 0\n", + "RooProduct::eff_cat28_procTOP_with_sys[ eff_cat28_procTOP * response_sysbtag_efficiency_cat28_procTOP * response_sysid_efficiency_cat28_procTOP ] = 0.0455974\n", + "RooProduct::eff_cat28_procVBF_with_sys[ eff_cat28_procVBF * response_sysbtag_efficiency_cat28_procVBF * response_sysid_efficiency_cat28_procVBF ] = 0\n", + "RooProduct::eff_cat28_procVH_with_sys[ eff_cat28_procVH * response_sysbtag_efficiency_cat28_procVH * response_sysid_efficiency_cat28_procVH ] = 0.000121035\n", + "RooProduct::eff_cat28_procggF_with_sys[ eff_cat28_procggF * response_sysbtag_efficiency_cat28_procggF * response_sysid_efficiency_cat28_procggF ] = 0\n", + "RooProduct::eff_cat2_procTOP_with_sys[ eff_cat2_procTOP * response_sysbtag_efficiency_cat2_procTOP * response_sysid_efficiency_cat2_procTOP ] = 0.00161498\n", + "RooProduct::eff_cat2_procVBF_with_sys[ eff_cat2_procVBF * response_sysbtag_efficiency_cat2_procVBF * response_sysid_efficiency_cat2_procVBF ] = 0.0493285\n", + "RooProduct::eff_cat2_procVH_with_sys[ eff_cat2_procVH * response_sysbtag_efficiency_cat2_procVH * response_sysid_efficiency_cat2_procVH ] = 0.0410382\n", + "RooProduct::eff_cat2_procggF_with_sys[ eff_cat2_procggF * response_sysbtag_efficiency_cat2_procggF * response_sysid_efficiency_cat2_procggF ] = 0.0632723\n", + "RooProduct::eff_cat3_procTOP_with_sys[ eff_cat3_procTOP * response_sysbtag_efficiency_cat3_procTOP * response_sysid_efficiency_cat3_procTOP ] = 0.0017531\n", + "RooProduct::eff_cat3_procVBF_with_sys[ eff_cat3_procVBF * response_sysbtag_efficiency_cat3_procVBF * response_sysid_efficiency_cat3_procVBF ] = 0.0544007\n", + "RooProduct::eff_cat3_procVH_with_sys[ eff_cat3_procVH * response_sysbtag_efficiency_cat3_procVH * response_sysid_efficiency_cat3_procVH ] = 0.0360506\n", + "RooProduct::eff_cat3_procggF_with_sys[ eff_cat3_procggF * response_sysbtag_efficiency_cat3_procggF * response_sysid_efficiency_cat3_procggF ] = 0.0306302\n", + "RooProduct::eff_cat4_procTOP_with_sys[ eff_cat4_procTOP * response_sysbtag_efficiency_cat4_procTOP * response_sysid_efficiency_cat4_procTOP ] = 0.000753345\n", + "RooProduct::eff_cat4_procVBF_with_sys[ eff_cat4_procVBF * response_sysbtag_efficiency_cat4_procVBF * response_sysid_efficiency_cat4_procVBF ] = 0.0172063\n", + "RooProduct::eff_cat4_procVH_with_sys[ eff_cat4_procVH * response_sysbtag_efficiency_cat4_procVH * response_sysid_efficiency_cat4_procVH ] = 0.0108921\n", + "RooProduct::eff_cat4_procggF_with_sys[ eff_cat4_procggF * response_sysbtag_efficiency_cat4_procggF * response_sysid_efficiency_cat4_procggF ] = 0.00580298\n", + "RooProduct::eff_cat5_procTOP_with_sys[ eff_cat5_procTOP * response_sysbtag_efficiency_cat5_procTOP * response_sysid_efficiency_cat5_procTOP ] = 0.000283603\n", + "RooProduct::eff_cat5_procVBF_with_sys[ eff_cat5_procVBF * response_sysbtag_efficiency_cat5_procVBF * response_sysid_efficiency_cat5_procVBF ] = 0.00509555\n", + "RooProduct::eff_cat5_procVH_with_sys[ eff_cat5_procVH * response_sysbtag_efficiency_cat5_procVH * response_sysid_efficiency_cat5_procVH ] = 0.00325223\n", + "RooProduct::eff_cat5_procggF_with_sys[ eff_cat5_procggF * response_sysbtag_efficiency_cat5_procggF * response_sysid_efficiency_cat5_procggF ] = 0.00147099\n", + "RooProduct::eff_cat6_procTOP_with_sys[ eff_cat6_procTOP * response_sysbtag_efficiency_cat6_procTOP * response_sysid_efficiency_cat6_procTOP ] = 0.0200158\n", + "RooProduct::eff_cat6_procVBF_with_sys[ eff_cat6_procVBF * response_sysbtag_efficiency_cat6_procVBF * response_sysid_efficiency_cat6_procVBF ] = 0.0234817\n", + "RooProduct::eff_cat6_procVH_with_sys[ eff_cat6_procVH * response_sysbtag_efficiency_cat6_procVH * response_sysid_efficiency_cat6_procVH ] = 0.0326839\n", + "RooProduct::eff_cat6_procggF_with_sys[ eff_cat6_procggF * response_sysbtag_efficiency_cat6_procggF * response_sysid_efficiency_cat6_procggF ] = 0.01642\n", + "RooProduct::eff_cat7_procTOP_with_sys[ eff_cat7_procTOP * response_sysbtag_efficiency_cat7_procTOP * response_sysid_efficiency_cat7_procTOP ] = 0.0205597\n", + "RooProduct::eff_cat7_procVBF_with_sys[ eff_cat7_procVBF * response_sysbtag_efficiency_cat7_procVBF * response_sysid_efficiency_cat7_procVBF ] = 0.0265507\n", + "RooProduct::eff_cat7_procVH_with_sys[ eff_cat7_procVH * response_sysbtag_efficiency_cat7_procVH * response_sysid_efficiency_cat7_procVH ] = 0.0295846\n", + "RooProduct::eff_cat7_procggF_with_sys[ eff_cat7_procggF * response_sysbtag_efficiency_cat7_procggF * response_sysid_efficiency_cat7_procggF ] = 0.0132634\n", + "RooProduct::eff_cat8_procTOP_with_sys[ eff_cat8_procTOP * response_sysbtag_efficiency_cat8_procTOP * response_sysid_efficiency_cat8_procTOP ] = 0.00845197\n", + "RooProduct::eff_cat8_procVBF_with_sys[ eff_cat8_procVBF * response_sysbtag_efficiency_cat8_procVBF * response_sysid_efficiency_cat8_procVBF ] = 0.0115379\n", + "RooProduct::eff_cat8_procVH_with_sys[ eff_cat8_procVH * response_sysbtag_efficiency_cat8_procVH * response_sysid_efficiency_cat8_procVH ] = 0.0134674\n", + "RooProduct::eff_cat8_procggF_with_sys[ eff_cat8_procggF * response_sysbtag_efficiency_cat8_procggF * response_sysid_efficiency_cat8_procggF ] = 0.00541439\n", + "RooProduct::eff_cat9_procTOP_with_sys[ eff_cat9_procTOP * response_sysbtag_efficiency_cat9_procTOP * response_sysid_efficiency_cat9_procTOP ] = 0.00283568\n", + "RooProduct::eff_cat9_procVBF_with_sys[ eff_cat9_procVBF * response_sysbtag_efficiency_cat9_procVBF * response_sysid_efficiency_cat9_procVBF ] = 0.00226449\n", + "RooProduct::eff_cat9_procVH_with_sys[ eff_cat9_procVH * response_sysbtag_efficiency_cat9_procVH * response_sysid_efficiency_cat9_procVH ] = 0.00369473\n", + "RooProduct::eff_cat9_procggF_with_sys[ eff_cat9_procggF * response_sysbtag_efficiency_cat9_procggF * response_sysid_efficiency_cat9_procggF ] = 0.00132996\n", + "RooFormulaVar::k_TOP_prod[ actualVars=(kF) formula=\"@0*@0\" ] = 1\n", + "RooFormulaVar::k_VBF_prod[ actualVars=(kV) formula=\"@0*@0\" ] = 1\n", + "RooFormulaVar::k_VH_prod[ actualVars=(kV) formula=\"@0*@0\" ] = 1\n", + "RooFormulaVar::k_ggF_prod[ actualVars=(kF) formula=\"@0*@0\" ] = 1\n", + "RooFormulaVar::k_higgs[ actualVars=(kF,kV) formula=\"0.75*@0*@0+0.25*@1*@1\" ] = 1\n", + "RooFormulaVar::k_yy_decay[ actualVars=(kV,kF) formula=\"1.59*@0*@0+0.07*@1*@1-0.67*@0*@1\" ] = 0.99\n", + "RooFormulaVar::mu_TOP[ actualVars=(k_TOP_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.99\n", + "RooFormulaVar::mu_VBF[ actualVars=(k_VBF_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.989999\n", + "RooFormulaVar::mu_VH[ actualVars=(k_VH_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.989999\n", + "RooFormulaVar::mu_ggF[ actualVars=(k_ggF_prod,k_yy_decay,k_higgs) formula=\"@0*@1/@2\" ] = 0.99\n", + "RooAddition::nexp_cat0[ nexp_signal_cat0_procggF + nexp_signal_cat0_procVBF + nexp_signal_cat0_procVH + nexp_signal_cat0_procTOP + nexp_bkg_cat0 ] = 13621.8\n", + "RooAddition::nexp_cat1[ nexp_signal_cat1_procggF + nexp_signal_cat1_procVBF + nexp_signal_cat1_procVH + nexp_signal_cat1_procTOP + nexp_bkg_cat1 ] = 47096.2\n", + "RooAddition::nexp_cat10[ nexp_signal_cat10_procggF + nexp_signal_cat10_procVBF + nexp_signal_cat10_procVH + nexp_signal_cat10_procTOP + nexp_bkg_cat10 ] = 316.875\n", + "RooAddition::nexp_cat11[ nexp_signal_cat11_procggF + nexp_signal_cat11_procVBF + nexp_signal_cat11_procVH + nexp_signal_cat11_procTOP + nexp_bkg_cat11 ] = 61.1012\n", + "RooAddition::nexp_cat12[ nexp_signal_cat12_procggF + nexp_signal_cat12_procVBF + nexp_signal_cat12_procVH + nexp_signal_cat12_procTOP + nexp_bkg_cat12 ] = 723.948\n", + "RooAddition::nexp_cat13[ nexp_signal_cat13_procggF + nexp_signal_cat13_procVBF + nexp_signal_cat13_procVH + nexp_signal_cat13_procTOP + nexp_bkg_cat13 ] = 360.811\n", + "RooAddition::nexp_cat14[ nexp_signal_cat14_procggF + nexp_signal_cat14_procVBF + nexp_signal_cat14_procVH + nexp_signal_cat14_procTOP + nexp_bkg_cat14 ] = 500.52\n", + "RooAddition::nexp_cat15[ nexp_signal_cat15_procggF + nexp_signal_cat15_procVBF + nexp_signal_cat15_procVH + nexp_signal_cat15_procTOP + nexp_bkg_cat15 ] = 132.625\n", + "RooAddition::nexp_cat16[ nexp_signal_cat16_procggF + nexp_signal_cat16_procVBF + nexp_signal_cat16_procVH + nexp_signal_cat16_procTOP + nexp_bkg_cat16 ] = 647.711\n", + "RooAddition::nexp_cat17[ nexp_signal_cat17_procggF + nexp_signal_cat17_procVBF + nexp_signal_cat17_procVH + nexp_signal_cat17_procTOP + nexp_bkg_cat17 ] = 11.0828\n", + "RooAddition::nexp_cat18[ nexp_signal_cat18_procggF + nexp_signal_cat18_procVBF + nexp_signal_cat18_procVH + nexp_signal_cat18_procTOP + nexp_bkg_cat18 ] = 8.91902\n", + "RooAddition::nexp_cat19[ nexp_signal_cat19_procggF + nexp_signal_cat19_procVBF + nexp_signal_cat19_procVH + nexp_signal_cat19_procTOP + nexp_bkg_cat19 ] = 106.072\n", + "RooAddition::nexp_cat2[ nexp_signal_cat2_procggF + nexp_signal_cat2_procVBF + nexp_signal_cat2_procVH + nexp_signal_cat2_procTOP + nexp_bkg_cat2 ] = 19554\n", + "RooAddition::nexp_cat20[ nexp_signal_cat20_procggF + nexp_signal_cat20_procVBF + nexp_signal_cat20_procVH + nexp_signal_cat20_procTOP + nexp_bkg_cat20 ] = 8.04832\n", + "RooAddition::nexp_cat21[ nexp_signal_cat21_procggF + nexp_signal_cat21_procVBF + nexp_signal_cat21_procVH + nexp_signal_cat21_procTOP + nexp_bkg_cat21 ] = 4.22619\n", + "RooAddition::nexp_cat22[ nexp_signal_cat22_procggF + nexp_signal_cat22_procVBF + nexp_signal_cat22_procVH + nexp_signal_cat22_procTOP + nexp_bkg_cat22 ] = 61.1529\n", + "RooAddition::nexp_cat23[ nexp_signal_cat23_procggF + nexp_signal_cat23_procVBF + nexp_signal_cat23_procVH + nexp_signal_cat23_procTOP + nexp_bkg_cat23 ] = 39.6653\n", + "RooAddition::nexp_cat24[ nexp_signal_cat24_procggF + nexp_signal_cat24_procVBF + nexp_signal_cat24_procVH + nexp_signal_cat24_procTOP + nexp_bkg_cat24 ] = 12.3248\n", + "RooAddition::nexp_cat25[ nexp_signal_cat25_procggF + nexp_signal_cat25_procVBF + nexp_signal_cat25_procVH + nexp_signal_cat25_procTOP + nexp_bkg_cat25 ] = 6.13154\n", + "RooAddition::nexp_cat26[ nexp_signal_cat26_procggF + nexp_signal_cat26_procVBF + nexp_signal_cat26_procVH + nexp_signal_cat26_procTOP + nexp_bkg_cat26 ] = 5.8404\n", + "RooAddition::nexp_cat27[ nexp_signal_cat27_procggF + nexp_signal_cat27_procVBF + nexp_signal_cat27_procVH + nexp_signal_cat27_procTOP + nexp_bkg_cat27 ] = 7.45624\n", + "RooAddition::nexp_cat28[ nexp_signal_cat28_procggF + nexp_signal_cat28_procVBF + nexp_signal_cat28_procVH + nexp_signal_cat28_procTOP + nexp_bkg_cat28 ] = 7.04041\n", + "RooAddition::nexp_cat3[ nexp_signal_cat3_procggF + nexp_signal_cat3_procVBF + nexp_signal_cat3_procVH + nexp_signal_cat3_procTOP + nexp_bkg_cat3 ] = 7193.41\n", + "RooAddition::nexp_cat4[ nexp_signal_cat4_procggF + nexp_signal_cat4_procVBF + nexp_signal_cat4_procVH + nexp_signal_cat4_procTOP + nexp_bkg_cat4 ] = 701.448\n", + "RooAddition::nexp_cat5[ nexp_signal_cat5_procggF + nexp_signal_cat5_procVBF + nexp_signal_cat5_procVH + nexp_signal_cat5_procTOP + nexp_bkg_cat5 ] = 96.2259\n", + "RooAddition::nexp_cat6[ nexp_signal_cat6_procggF + nexp_signal_cat6_procVBF + nexp_signal_cat6_procVH + nexp_signal_cat6_procTOP + nexp_bkg_cat6 ] = 7860.49\n", + "RooAddition::nexp_cat7[ nexp_signal_cat7_procggF + nexp_signal_cat7_procVBF + nexp_signal_cat7_procVH + nexp_signal_cat7_procTOP + nexp_bkg_cat7 ] = 4236.03\n", + "RooAddition::nexp_cat8[ nexp_signal_cat8_procggF + nexp_signal_cat8_procVBF + nexp_signal_cat8_procVH + nexp_signal_cat8_procTOP + nexp_bkg_cat8 ] = 746.478\n", + "RooAddition::nexp_cat9[ nexp_signal_cat9_procggF + nexp_signal_cat9_procVBF + nexp_signal_cat9_procVH + nexp_signal_cat9_procTOP + nexp_bkg_cat9 ] = 74.7314\n", + "RooProduct::nexp_signal_cat0_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat0_procTOP_with_sys ] = 0.0209697\n", + "RooProduct::nexp_signal_cat0_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat0_procVBF_with_sys ] = 6.61118\n", + "RooProduct::nexp_signal_cat0_procVH[ nsignal_gen_procVH_with_sys * eff_cat0_procVH_with_sys ] = 5.2105\n", + "RooProduct::nexp_signal_cat0_procggF[ nsignal_gen_procggF_with_sys * eff_cat0_procggF_with_sys ] = 609.909\n", + "RooProduct::nexp_signal_cat10_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat10_procTOP_with_sys ] = 0.0609926\n", + "RooProduct::nexp_signal_cat10_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat10_procVBF_with_sys ] = 23.8434\n", + "RooProduct::nexp_signal_cat10_procVH[ nsignal_gen_procVH_with_sys * eff_cat10_procVH_with_sys ] = 0.255638\n", + "RooProduct::nexp_signal_cat10_procggF[ nsignal_gen_procggF_with_sys * eff_cat10_procggF_with_sys ] = 12.715\n", + "RooProduct::nexp_signal_cat11_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat11_procTOP_with_sys ] = 0.0422311\n", + "RooProduct::nexp_signal_cat11_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat11_procVBF_with_sys ] = 22.6993\n", + "RooProduct::nexp_signal_cat11_procVH[ nsignal_gen_procVH_with_sys * eff_cat11_procVH_with_sys ] = 0.0546109\n", + "RooProduct::nexp_signal_cat11_procggF[ nsignal_gen_procggF_with_sys * eff_cat11_procggF_with_sys ] = 3.30504\n", + "RooProduct::nexp_signal_cat12_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat12_procTOP_with_sys ] = 0.409891\n", + "RooProduct::nexp_signal_cat12_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat12_procVBF_with_sys ] = 7.83071\n", + "RooProduct::nexp_signal_cat12_procVH[ nsignal_gen_procVH_with_sys * eff_cat12_procVH_with_sys ] = 1.40068\n", + "RooProduct::nexp_signal_cat12_procggF[ nsignal_gen_procggF_with_sys * eff_cat12_procggF_with_sys ] = 24.3067\n", + "RooProduct::nexp_signal_cat13_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat13_procTOP_with_sys ] = 0.711242\n", + "RooProduct::nexp_signal_cat13_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat13_procVBF_with_sys ] = 19.2456\n", + "RooProduct::nexp_signal_cat13_procVH[ nsignal_gen_procVH_with_sys * eff_cat13_procVH_with_sys ] = 1.09125\n", + "RooProduct::nexp_signal_cat13_procggF[ nsignal_gen_procggF_with_sys * eff_cat13_procggF_with_sys ] = 19.7631\n", + "RooProduct::nexp_signal_cat14_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat14_procTOP_with_sys ] = 0.466422\n", + "RooProduct::nexp_signal_cat14_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat14_procVBF_with_sys ] = 1.60882\n", + "RooProduct::nexp_signal_cat14_procVH[ nsignal_gen_procVH_with_sys * eff_cat14_procVH_with_sys ] = 7.92036\n", + "RooProduct::nexp_signal_cat14_procggF[ nsignal_gen_procggF_with_sys * eff_cat14_procggF_with_sys ] = 20.5244\n", + "RooProduct::nexp_signal_cat15_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat15_procTOP_with_sys ] = 0.306223\n", + "RooProduct::nexp_signal_cat15_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat15_procVBF_with_sys ] = 0.810366\n", + "RooProduct::nexp_signal_cat15_procVH[ nsignal_gen_procVH_with_sys * eff_cat15_procVH_with_sys ] = 9.6279\n", + "RooProduct::nexp_signal_cat15_procggF[ nsignal_gen_procggF_with_sys * eff_cat15_procggF_with_sys ] = 11.8809\n", + "RooProduct::nexp_signal_cat16_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat16_procTOP_with_sys ] = 1.56173\n", + "RooProduct::nexp_signal_cat16_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat16_procVBF_with_sys ] = 10.3464\n", + "RooProduct::nexp_signal_cat16_procVH[ nsignal_gen_procVH_with_sys * eff_cat16_procVH_with_sys ] = 4.40212\n", + "RooProduct::nexp_signal_cat16_procggF[ nsignal_gen_procggF_with_sys * eff_cat16_procggF_with_sys ] = 21.4012\n", + "RooProduct::nexp_signal_cat17_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat17_procTOP_with_sys ] = 0.00826055\n", + "RooProduct::nexp_signal_cat17_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat17_procVBF_with_sys ] = 0.0136196\n", + "RooProduct::nexp_signal_cat17_procVH[ nsignal_gen_procVH_with_sys * eff_cat17_procVH_with_sys ] = 1.0545\n", + "RooProduct::nexp_signal_cat17_procggF[ nsignal_gen_procggF_with_sys * eff_cat17_procggF_with_sys ] = 0.206372\n", + "RooProduct::nexp_signal_cat18_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat18_procTOP_with_sys ] = 0.130278\n", + "RooProduct::nexp_signal_cat18_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat18_procVBF_with_sys ] = 0.0034049\n", + "RooProduct::nexp_signal_cat18_procVH[ nsignal_gen_procVH_with_sys * eff_cat18_procVH_with_sys ] = 2.25643\n", + "RooProduct::nexp_signal_cat18_procggF[ nsignal_gen_procggF_with_sys * eff_cat18_procggF_with_sys ] = 0.028909\n", + "RooProduct::nexp_signal_cat19_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat19_procTOP_with_sys ] = 1.19299\n", + "RooProduct::nexp_signal_cat19_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat19_procVBF_with_sys ] = 0.107254\n", + "RooProduct::nexp_signal_cat19_procVH[ nsignal_gen_procVH_with_sys * eff_cat19_procVH_with_sys ] = 8.64009\n", + "RooProduct::nexp_signal_cat19_procggF[ nsignal_gen_procggF_with_sys * eff_cat19_procggF_with_sys ] = 1.13165\n", + "RooProduct::nexp_signal_cat1_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat1_procTOP_with_sys ] = 0.0488893\n", + "RooProduct::nexp_signal_cat1_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat1_procVBF_with_sys ] = 12.8126\n", + "RooProduct::nexp_signal_cat1_procVH[ nsignal_gen_procVH_with_sys * eff_cat1_procVH_with_sys ] = 10.7876\n", + "RooProduct::nexp_signal_cat1_procggF[ nsignal_gen_procggF_with_sys * eff_cat1_procggF_with_sys ] = 1072.59\n", + "RooProduct::nexp_signal_cat20_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat20_procTOP_with_sys ] = 0.461731\n", + "RooProduct::nexp_signal_cat20_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat20_procVBF_with_sys ] = 0.00170245\n", + "RooProduct::nexp_signal_cat20_procVH[ nsignal_gen_procVH_with_sys * eff_cat20_procVH_with_sys ] = 2.28488\n", + "RooProduct::nexp_signal_cat20_procggF[ nsignal_gen_procggF_with_sys * eff_cat20_procggF_with_sys ] = 0\n", + "RooProduct::nexp_signal_cat21_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat21_procTOP_with_sys ] = 0.0212864\n", + "RooProduct::nexp_signal_cat21_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat21_procVBF_with_sys ] = 0\n", + "RooProduct::nexp_signal_cat21_procVH[ nsignal_gen_procVH_with_sys * eff_cat21_procVH_with_sys ] = 1.60491\n", + "RooProduct::nexp_signal_cat21_procggF[ nsignal_gen_procggF_with_sys * eff_cat21_procggF_with_sys ] = 0\n", + "RooProduct::nexp_signal_cat22_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat22_procTOP_with_sys ] = 3.54967\n", + "RooProduct::nexp_signal_cat22_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat22_procVBF_with_sys ] = 0.217914\n", + "RooProduct::nexp_signal_cat22_procVH[ nsignal_gen_procVH_with_sys * eff_cat22_procVH_with_sys ] = 0.895968\n", + "RooProduct::nexp_signal_cat22_procggF[ nsignal_gen_procggF_with_sys * eff_cat22_procggF_with_sys ] = 1.48937\n", + "RooProduct::nexp_signal_cat23_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat23_procTOP_with_sys ] = 5.19066\n", + "RooProduct::nexp_signal_cat23_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat23_procVBF_with_sys ] = 0.0936348\n", + "RooProduct::nexp_signal_cat23_procVH[ nsignal_gen_procVH_with_sys * eff_cat23_procVH_with_sys ] = 0.552896\n", + "RooProduct::nexp_signal_cat23_procggF[ nsignal_gen_procggF_with_sys * eff_cat23_procggF_with_sys ] = 0.82807\n", + "RooProduct::nexp_signal_cat24_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat24_procTOP_with_sys ] = 3.66529\n", + "RooProduct::nexp_signal_cat24_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat24_procVBF_with_sys ] = 0.0272392\n", + "RooProduct::nexp_signal_cat24_procVH[ nsignal_gen_procVH_with_sys * eff_cat24_procVH_with_sys ] = 0.183861\n", + "RooProduct::nexp_signal_cat24_procggF[ nsignal_gen_procggF_with_sys * eff_cat24_procggF_with_sys ] = 0.248377\n", + "RooProduct::nexp_signal_cat25_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat25_procTOP_with_sys ] = 4.46106\n", + "RooProduct::nexp_signal_cat25_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat25_procVBF_with_sys ] = 0.0147546\n", + "RooProduct::nexp_signal_cat25_procVH[ nsignal_gen_procVH_with_sys * eff_cat25_procVH_with_sys ] = 0.127278\n", + "RooProduct::nexp_signal_cat25_procggF[ nsignal_gen_procggF_with_sys * eff_cat25_procggF_with_sys ] = 0.128449\n", + "RooProduct::nexp_signal_cat26_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat26_procTOP_with_sys ] = 1.03076\n", + "RooProduct::nexp_signal_cat26_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat26_procVBF_with_sys ] = 0.00113497\n", + "RooProduct::nexp_signal_cat26_procVH[ nsignal_gen_procVH_with_sys * eff_cat26_procVH_with_sys ] = 0.100495\n", + "RooProduct::nexp_signal_cat26_procggF[ nsignal_gen_procggF_with_sys * eff_cat26_procggF_with_sys ] = 0.00800412\n", + "RooProduct::nexp_signal_cat27_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat27_procTOP_with_sys ] = 2.48215\n", + "RooProduct::nexp_signal_cat27_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat27_procVBF_with_sys ] = 0.000567484\n", + "RooProduct::nexp_signal_cat27_procVH[ nsignal_gen_procVH_with_sys * eff_cat27_procVH_with_sys ] = 0.073519\n", + "RooProduct::nexp_signal_cat27_procggF[ nsignal_gen_procggF_with_sys * eff_cat27_procggF_with_sys ] = 0\n", + "RooProduct::nexp_signal_cat28_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat28_procTOP_with_sys ] = 4.79704\n", + "RooProduct::nexp_signal_cat28_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat28_procVBF_with_sys ] = 0\n", + "RooProduct::nexp_signal_cat28_procVH[ nsignal_gen_procVH_with_sys * eff_cat28_procVH_with_sys ] = 0.0433702\n", + "RooProduct::nexp_signal_cat28_procggF[ nsignal_gen_procggF_with_sys * eff_cat28_procggF_with_sys ] = 0\n", + "RooProduct::nexp_signal_cat2_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat2_procTOP_with_sys ] = 0.169903\n", + "RooProduct::nexp_signal_cat2_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat2_procVBF_with_sys ] = 31.1764\n", + "RooProduct::nexp_signal_cat2_procVH[ nsignal_gen_procVH_with_sys * eff_cat2_procVH_with_sys ] = 14.7051\n", + "RooProduct::nexp_signal_cat2_procggF[ nsignal_gen_procggF_with_sys * eff_cat2_procggF_with_sys ] = 507.997\n", + "RooProduct::nexp_signal_cat3_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat3_procTOP_with_sys ] = 0.184433\n", + "RooProduct::nexp_signal_cat3_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat3_procVBF_with_sys ] = 34.3821\n", + "RooProduct::nexp_signal_cat3_procVH[ nsignal_gen_procVH_with_sys * eff_cat3_procVH_with_sys ] = 12.9179\n", + "RooProduct::nexp_signal_cat3_procggF[ nsignal_gen_procggF_with_sys * eff_cat3_procggF_with_sys ] = 245.922\n", + "RooProduct::nexp_signal_cat4_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat4_procTOP_with_sys ] = 0.0792552\n", + "RooProduct::nexp_signal_cat4_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat4_procVBF_with_sys ] = 10.8747\n", + "RooProduct::nexp_signal_cat4_procVH[ nsignal_gen_procVH_with_sys * eff_cat4_procVH_with_sys ] = 3.90295\n", + "RooProduct::nexp_signal_cat4_procggF[ nsignal_gen_procggF_with_sys * eff_cat4_procggF_with_sys ] = 46.5907\n", + "RooProduct::nexp_signal_cat5_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat5_procTOP_with_sys ] = 0.0298362\n", + "RooProduct::nexp_signal_cat5_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat5_procVBF_with_sys ] = 3.22047\n", + "RooProduct::nexp_signal_cat5_procVH[ nsignal_gen_procVH_with_sys * eff_cat5_procVH_with_sys ] = 1.16536\n", + "RooProduct::nexp_signal_cat5_procggF[ nsignal_gen_procggF_with_sys * eff_cat5_procggF_with_sys ] = 11.8102\n", + "RooProduct::nexp_signal_cat6_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat6_procTOP_with_sys ] = 2.10575\n", + "RooProduct::nexp_signal_cat6_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat6_procVBF_with_sys ] = 14.8408\n", + "RooProduct::nexp_signal_cat6_procVH[ nsignal_gen_procVH_with_sys * eff_cat6_procVH_with_sys ] = 11.7115\n", + "RooProduct::nexp_signal_cat6_procggF[ nsignal_gen_procggF_with_sys * eff_cat6_procggF_with_sys ] = 131.832\n", + "RooProduct::nexp_signal_cat7_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat7_procTOP_with_sys ] = 2.16297\n", + "RooProduct::nexp_signal_cat7_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat7_procVBF_with_sys ] = 16.7805\n", + "RooProduct::nexp_signal_cat7_procVH[ nsignal_gen_procVH_with_sys * eff_cat7_procVH_with_sys ] = 10.601\n", + "RooProduct::nexp_signal_cat7_procggF[ nsignal_gen_procggF_with_sys * eff_cat7_procggF_with_sys ] = 106.489\n", + "RooProduct::nexp_signal_cat8_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat8_procTOP_with_sys ] = 0.889184\n", + "RooProduct::nexp_signal_cat8_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat8_procVBF_with_sys ] = 7.29216\n", + "RooProduct::nexp_signal_cat8_procVH[ nsignal_gen_procVH_with_sys * eff_cat8_procVH_with_sys ] = 4.82574\n", + "RooProduct::nexp_signal_cat8_procggF[ nsignal_gen_procggF_with_sys * eff_cat8_procggF_with_sys ] = 43.4708\n", + "RooProduct::nexp_signal_cat9_procTOP[ nsignal_gen_procTOP_with_sys * eff_cat9_procTOP_with_sys ] = 0.298326\n", + "RooProduct::nexp_signal_cat9_procVBF[ nsignal_gen_procVBF_with_sys * eff_cat9_procVBF_with_sys ] = 1.43119\n", + "RooProduct::nexp_signal_cat9_procVH[ nsignal_gen_procVH_with_sys * eff_cat9_procVH_with_sys ] = 1.32392\n", + "RooProduct::nexp_signal_cat9_procggF[ nsignal_gen_procggF_with_sys * eff_cat9_procggF_with_sys ] = 10.6779\n", + "RooProduct::nsignal_gen_procTOP[ mu_TOP * lumi * xsec_TOP ] = 105.204\n", + "RooProduct::nsignal_gen_procTOP_with_sys[ nsignal_gen_procTOP * response_syslumi_nprod_procTOP ] = 105.204\n", + "RooProduct::nsignal_gen_procVBF[ mu_VBF * lumi * xsec_VBF ] = 632.016\n", + "RooProduct::nsignal_gen_procVBF_with_sys[ nsignal_gen_procVBF * response_syslumi_nprod_procVBF ] = 632.016\n", + "RooProduct::nsignal_gen_procVH[ mu_VH * lumi * xsec_VH ] = 358.327\n", + "RooProduct::nsignal_gen_procVH_with_sys[ nsignal_gen_procVH * response_syslumi_nprod_procVH ] = 358.327\n", + "RooProduct::nsignal_gen_procggF[ mu_ggF * lumi * xsec_ggF ] = 8028.75\n", + "RooProduct::nsignal_gen_procggF_with_sys[ nsignal_gen_procggF * response_syslumi_nprod_procggF ] = 8028.75\n", + "RooFormulaVar::response_sysbtag_efficiency_cat0_procTOP[ actualVars=(sigma_btag_efficiency_cat0_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat0_procVBF[ actualVars=(sigma_btag_efficiency_cat0_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat0_procVH[ actualVars=(sigma_btag_efficiency_cat0_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat0_procggF[ actualVars=(sigma_btag_efficiency_cat0_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat10_procTOP[ actualVars=(sigma_btag_efficiency_cat10_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat10_procVBF[ actualVars=(sigma_btag_efficiency_cat10_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat10_procVH[ actualVars=(sigma_btag_efficiency_cat10_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat10_procggF[ actualVars=(sigma_btag_efficiency_cat10_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat11_procTOP[ actualVars=(sigma_btag_efficiency_cat11_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat11_procVBF[ actualVars=(sigma_btag_efficiency_cat11_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat11_procVH[ actualVars=(sigma_btag_efficiency_cat11_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat11_procggF[ actualVars=(sigma_btag_efficiency_cat11_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat12_procTOP[ actualVars=(sigma_btag_efficiency_cat12_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat12_procVBF[ actualVars=(sigma_btag_efficiency_cat12_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat12_procVH[ actualVars=(sigma_btag_efficiency_cat12_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat12_procggF[ actualVars=(sigma_btag_efficiency_cat12_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat13_procTOP[ actualVars=(sigma_btag_efficiency_cat13_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat13_procVBF[ actualVars=(sigma_btag_efficiency_cat13_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat13_procVH[ actualVars=(sigma_btag_efficiency_cat13_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat13_procggF[ actualVars=(sigma_btag_efficiency_cat13_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat14_procTOP[ actualVars=(sigma_btag_efficiency_cat14_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat14_procVBF[ actualVars=(sigma_btag_efficiency_cat14_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat14_procVH[ actualVars=(sigma_btag_efficiency_cat14_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat14_procggF[ actualVars=(sigma_btag_efficiency_cat14_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat15_procTOP[ actualVars=(sigma_btag_efficiency_cat15_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat15_procVBF[ actualVars=(sigma_btag_efficiency_cat15_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat15_procVH[ actualVars=(sigma_btag_efficiency_cat15_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat15_procggF[ actualVars=(sigma_btag_efficiency_cat15_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat16_procTOP[ actualVars=(sigma_btag_efficiency_cat16_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat16_procVBF[ actualVars=(sigma_btag_efficiency_cat16_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat16_procVH[ actualVars=(sigma_btag_efficiency_cat16_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat16_procggF[ actualVars=(sigma_btag_efficiency_cat16_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat17_procTOP[ actualVars=(sigma_btag_efficiency_cat17_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat17_procVBF[ actualVars=(sigma_btag_efficiency_cat17_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat17_procVH[ actualVars=(sigma_btag_efficiency_cat17_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat17_procggF[ actualVars=(sigma_btag_efficiency_cat17_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat18_procTOP[ actualVars=(sigma_btag_efficiency_cat18_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat18_procVBF[ actualVars=(sigma_btag_efficiency_cat18_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat18_procVH[ actualVars=(sigma_btag_efficiency_cat18_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat18_procggF[ actualVars=(sigma_btag_efficiency_cat18_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat19_procTOP[ actualVars=(sigma_btag_efficiency_cat19_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat19_procVBF[ actualVars=(sigma_btag_efficiency_cat19_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat19_procVH[ actualVars=(sigma_btag_efficiency_cat19_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat19_procggF[ actualVars=(sigma_btag_efficiency_cat19_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat1_procTOP[ actualVars=(sigma_btag_efficiency_cat1_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat1_procVBF[ actualVars=(sigma_btag_efficiency_cat1_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat1_procVH[ actualVars=(sigma_btag_efficiency_cat1_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat1_procggF[ actualVars=(sigma_btag_efficiency_cat1_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat20_procTOP[ actualVars=(sigma_btag_efficiency_cat20_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat20_procVBF[ actualVars=(sigma_btag_efficiency_cat20_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat20_procVH[ actualVars=(sigma_btag_efficiency_cat20_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat20_procggF[ actualVars=(sigma_btag_efficiency_cat20_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat21_procTOP[ actualVars=(sigma_btag_efficiency_cat21_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat21_procVBF[ actualVars=(sigma_btag_efficiency_cat21_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat21_procVH[ actualVars=(sigma_btag_efficiency_cat21_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat21_procggF[ actualVars=(sigma_btag_efficiency_cat21_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat22_procTOP[ actualVars=(sigma_btag_efficiency_cat22_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat22_procVBF[ actualVars=(sigma_btag_efficiency_cat22_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat22_procVH[ actualVars=(sigma_btag_efficiency_cat22_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat22_procggF[ actualVars=(sigma_btag_efficiency_cat22_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat23_procTOP[ actualVars=(sigma_btag_efficiency_cat23_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat23_procVBF[ actualVars=(sigma_btag_efficiency_cat23_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat23_procVH[ actualVars=(sigma_btag_efficiency_cat23_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat23_procggF[ actualVars=(sigma_btag_efficiency_cat23_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat24_procTOP[ actualVars=(sigma_btag_efficiency_cat24_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat24_procVBF[ actualVars=(sigma_btag_efficiency_cat24_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat24_procVH[ actualVars=(sigma_btag_efficiency_cat24_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat24_procggF[ actualVars=(sigma_btag_efficiency_cat24_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat25_procTOP[ actualVars=(sigma_btag_efficiency_cat25_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat25_procVBF[ actualVars=(sigma_btag_efficiency_cat25_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat25_procVH[ actualVars=(sigma_btag_efficiency_cat25_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat25_procggF[ actualVars=(sigma_btag_efficiency_cat25_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat26_procTOP[ actualVars=(sigma_btag_efficiency_cat26_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat26_procVBF[ actualVars=(sigma_btag_efficiency_cat26_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat26_procVH[ actualVars=(sigma_btag_efficiency_cat26_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat26_procggF[ actualVars=(sigma_btag_efficiency_cat26_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat27_procTOP[ actualVars=(sigma_btag_efficiency_cat27_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat27_procVBF[ actualVars=(sigma_btag_efficiency_cat27_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat27_procVH[ actualVars=(sigma_btag_efficiency_cat27_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat27_procggF[ actualVars=(sigma_btag_efficiency_cat27_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat28_procTOP[ actualVars=(sigma_btag_efficiency_cat28_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat28_procVBF[ actualVars=(sigma_btag_efficiency_cat28_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat28_procVH[ actualVars=(sigma_btag_efficiency_cat28_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat28_procggF[ actualVars=(sigma_btag_efficiency_cat28_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat2_procTOP[ actualVars=(sigma_btag_efficiency_cat2_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat2_procVBF[ actualVars=(sigma_btag_efficiency_cat2_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat2_procVH[ actualVars=(sigma_btag_efficiency_cat2_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat2_procggF[ actualVars=(sigma_btag_efficiency_cat2_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat3_procTOP[ actualVars=(sigma_btag_efficiency_cat3_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat3_procVBF[ actualVars=(sigma_btag_efficiency_cat3_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat3_procVH[ actualVars=(sigma_btag_efficiency_cat3_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat3_procggF[ actualVars=(sigma_btag_efficiency_cat3_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat4_procTOP[ actualVars=(sigma_btag_efficiency_cat4_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat4_procVBF[ actualVars=(sigma_btag_efficiency_cat4_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat4_procVH[ actualVars=(sigma_btag_efficiency_cat4_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat4_procggF[ actualVars=(sigma_btag_efficiency_cat4_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat5_procTOP[ actualVars=(sigma_btag_efficiency_cat5_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat5_procVBF[ actualVars=(sigma_btag_efficiency_cat5_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat5_procVH[ actualVars=(sigma_btag_efficiency_cat5_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat5_procggF[ actualVars=(sigma_btag_efficiency_cat5_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat6_procTOP[ actualVars=(sigma_btag_efficiency_cat6_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat6_procVBF[ actualVars=(sigma_btag_efficiency_cat6_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat6_procVH[ actualVars=(sigma_btag_efficiency_cat6_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat6_procggF[ actualVars=(sigma_btag_efficiency_cat6_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat7_procTOP[ actualVars=(sigma_btag_efficiency_cat7_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat7_procVBF[ actualVars=(sigma_btag_efficiency_cat7_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat7_procVH[ actualVars=(sigma_btag_efficiency_cat7_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat7_procggF[ actualVars=(sigma_btag_efficiency_cat7_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat8_procTOP[ actualVars=(sigma_btag_efficiency_cat8_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat8_procVBF[ actualVars=(sigma_btag_efficiency_cat8_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat8_procVH[ actualVars=(sigma_btag_efficiency_cat8_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat8_procggF[ actualVars=(sigma_btag_efficiency_cat8_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat9_procTOP[ actualVars=(sigma_btag_efficiency_cat9_procTOP,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat9_procVBF[ actualVars=(sigma_btag_efficiency_cat9_procVBF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat9_procVH[ actualVars=(sigma_btag_efficiency_cat9_procVH,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysbtag_efficiency_cat9_procggF[ actualVars=(sigma_btag_efficiency_cat9_procggF,theta_btag) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat0_procTOP[ actualVars=(sigma_id_efficiency_cat0_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat0_procVBF[ actualVars=(sigma_id_efficiency_cat0_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat0_procVH[ actualVars=(sigma_id_efficiency_cat0_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat0_procggF[ actualVars=(sigma_id_efficiency_cat0_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat10_procTOP[ actualVars=(sigma_id_efficiency_cat10_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat10_procVBF[ actualVars=(sigma_id_efficiency_cat10_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat10_procVH[ actualVars=(sigma_id_efficiency_cat10_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat10_procggF[ actualVars=(sigma_id_efficiency_cat10_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat11_procTOP[ actualVars=(sigma_id_efficiency_cat11_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat11_procVBF[ actualVars=(sigma_id_efficiency_cat11_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat11_procVH[ actualVars=(sigma_id_efficiency_cat11_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat11_procggF[ actualVars=(sigma_id_efficiency_cat11_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat12_procTOP[ actualVars=(sigma_id_efficiency_cat12_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat12_procVBF[ actualVars=(sigma_id_efficiency_cat12_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat12_procVH[ actualVars=(sigma_id_efficiency_cat12_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat12_procggF[ actualVars=(sigma_id_efficiency_cat12_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat13_procTOP[ actualVars=(sigma_id_efficiency_cat13_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat13_procVBF[ actualVars=(sigma_id_efficiency_cat13_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat13_procVH[ actualVars=(sigma_id_efficiency_cat13_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat13_procggF[ actualVars=(sigma_id_efficiency_cat13_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat14_procTOP[ actualVars=(sigma_id_efficiency_cat14_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat14_procVBF[ actualVars=(sigma_id_efficiency_cat14_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat14_procVH[ actualVars=(sigma_id_efficiency_cat14_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat14_procggF[ actualVars=(sigma_id_efficiency_cat14_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat15_procTOP[ actualVars=(sigma_id_efficiency_cat15_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat15_procVBF[ actualVars=(sigma_id_efficiency_cat15_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat15_procVH[ actualVars=(sigma_id_efficiency_cat15_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat15_procggF[ actualVars=(sigma_id_efficiency_cat15_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat16_procTOP[ actualVars=(sigma_id_efficiency_cat16_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat16_procVBF[ actualVars=(sigma_id_efficiency_cat16_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat16_procVH[ actualVars=(sigma_id_efficiency_cat16_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat16_procggF[ actualVars=(sigma_id_efficiency_cat16_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat17_procTOP[ actualVars=(sigma_id_efficiency_cat17_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat17_procVBF[ actualVars=(sigma_id_efficiency_cat17_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat17_procVH[ actualVars=(sigma_id_efficiency_cat17_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat17_procggF[ actualVars=(sigma_id_efficiency_cat17_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat18_procTOP[ actualVars=(sigma_id_efficiency_cat18_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat18_procVBF[ actualVars=(sigma_id_efficiency_cat18_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat18_procVH[ actualVars=(sigma_id_efficiency_cat18_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat18_procggF[ actualVars=(sigma_id_efficiency_cat18_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat19_procTOP[ actualVars=(sigma_id_efficiency_cat19_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat19_procVBF[ actualVars=(sigma_id_efficiency_cat19_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat19_procVH[ actualVars=(sigma_id_efficiency_cat19_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat19_procggF[ actualVars=(sigma_id_efficiency_cat19_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat1_procTOP[ actualVars=(sigma_id_efficiency_cat1_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat1_procVBF[ actualVars=(sigma_id_efficiency_cat1_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat1_procVH[ actualVars=(sigma_id_efficiency_cat1_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat1_procggF[ actualVars=(sigma_id_efficiency_cat1_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat20_procTOP[ actualVars=(sigma_id_efficiency_cat20_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat20_procVBF[ actualVars=(sigma_id_efficiency_cat20_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat20_procVH[ actualVars=(sigma_id_efficiency_cat20_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat20_procggF[ actualVars=(sigma_id_efficiency_cat20_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat21_procTOP[ actualVars=(sigma_id_efficiency_cat21_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat21_procVBF[ actualVars=(sigma_id_efficiency_cat21_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat21_procVH[ actualVars=(sigma_id_efficiency_cat21_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat21_procggF[ actualVars=(sigma_id_efficiency_cat21_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat22_procTOP[ actualVars=(sigma_id_efficiency_cat22_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat22_procVBF[ actualVars=(sigma_id_efficiency_cat22_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat22_procVH[ actualVars=(sigma_id_efficiency_cat22_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat22_procggF[ actualVars=(sigma_id_efficiency_cat22_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat23_procTOP[ actualVars=(sigma_id_efficiency_cat23_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat23_procVBF[ actualVars=(sigma_id_efficiency_cat23_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat23_procVH[ actualVars=(sigma_id_efficiency_cat23_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat23_procggF[ actualVars=(sigma_id_efficiency_cat23_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat24_procTOP[ actualVars=(sigma_id_efficiency_cat24_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat24_procVBF[ actualVars=(sigma_id_efficiency_cat24_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat24_procVH[ actualVars=(sigma_id_efficiency_cat24_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat24_procggF[ actualVars=(sigma_id_efficiency_cat24_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat25_procTOP[ actualVars=(sigma_id_efficiency_cat25_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat25_procVBF[ actualVars=(sigma_id_efficiency_cat25_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat25_procVH[ actualVars=(sigma_id_efficiency_cat25_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat25_procggF[ actualVars=(sigma_id_efficiency_cat25_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat26_procTOP[ actualVars=(sigma_id_efficiency_cat26_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat26_procVBF[ actualVars=(sigma_id_efficiency_cat26_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat26_procVH[ actualVars=(sigma_id_efficiency_cat26_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat26_procggF[ actualVars=(sigma_id_efficiency_cat26_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat27_procTOP[ actualVars=(sigma_id_efficiency_cat27_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat27_procVBF[ actualVars=(sigma_id_efficiency_cat27_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat27_procVH[ actualVars=(sigma_id_efficiency_cat27_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat27_procggF[ actualVars=(sigma_id_efficiency_cat27_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat28_procTOP[ actualVars=(sigma_id_efficiency_cat28_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat28_procVBF[ actualVars=(sigma_id_efficiency_cat28_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat28_procVH[ actualVars=(sigma_id_efficiency_cat28_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat28_procggF[ actualVars=(sigma_id_efficiency_cat28_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat2_procTOP[ actualVars=(sigma_id_efficiency_cat2_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat2_procVBF[ actualVars=(sigma_id_efficiency_cat2_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat2_procVH[ actualVars=(sigma_id_efficiency_cat2_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat2_procggF[ actualVars=(sigma_id_efficiency_cat2_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat3_procTOP[ actualVars=(sigma_id_efficiency_cat3_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat3_procVBF[ actualVars=(sigma_id_efficiency_cat3_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat3_procVH[ actualVars=(sigma_id_efficiency_cat3_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat3_procggF[ actualVars=(sigma_id_efficiency_cat3_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat4_procTOP[ actualVars=(sigma_id_efficiency_cat4_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat4_procVBF[ actualVars=(sigma_id_efficiency_cat4_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat4_procVH[ actualVars=(sigma_id_efficiency_cat4_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat4_procggF[ actualVars=(sigma_id_efficiency_cat4_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat5_procTOP[ actualVars=(sigma_id_efficiency_cat5_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat5_procVBF[ actualVars=(sigma_id_efficiency_cat5_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat5_procVH[ actualVars=(sigma_id_efficiency_cat5_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat5_procggF[ actualVars=(sigma_id_efficiency_cat5_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat6_procTOP[ actualVars=(sigma_id_efficiency_cat6_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat6_procVBF[ actualVars=(sigma_id_efficiency_cat6_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat6_procVH[ actualVars=(sigma_id_efficiency_cat6_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat6_procggF[ actualVars=(sigma_id_efficiency_cat6_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat7_procTOP[ actualVars=(sigma_id_efficiency_cat7_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat7_procVBF[ actualVars=(sigma_id_efficiency_cat7_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat7_procVH[ actualVars=(sigma_id_efficiency_cat7_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat7_procggF[ actualVars=(sigma_id_efficiency_cat7_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat8_procTOP[ actualVars=(sigma_id_efficiency_cat8_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat8_procVBF[ actualVars=(sigma_id_efficiency_cat8_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat8_procVH[ actualVars=(sigma_id_efficiency_cat8_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat8_procggF[ actualVars=(sigma_id_efficiency_cat8_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat9_procTOP[ actualVars=(sigma_id_efficiency_cat9_procTOP,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat9_procVBF[ actualVars=(sigma_id_efficiency_cat9_procVBF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat9_procVH[ actualVars=(sigma_id_efficiency_cat9_procVH,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_sysid_efficiency_cat9_procggF[ actualVars=(sigma_id_efficiency_cat9_procggF,theta_id) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_syslumi_nprod_procTOP[ actualVars=(sigma_lumi_nprod_procTOP,theta_lumi) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_syslumi_nprod_procVBF[ actualVars=(sigma_lumi_nprod_procVBF,theta_lumi) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_syslumi_nprod_procVH[ actualVars=(sigma_lumi_nprod_procVH,theta_lumi) formula=\"1+@0*@1\" ] = 1\n", + "RooFormulaVar::response_syslumi_nprod_procggF[ actualVars=(sigma_lumi_nprod_procggF,theta_lumi) formula=\"1+@0*@1\" ] = 1\n", + "\n", + "parameter snapshots\n", + "-------------------\n", + "initial = (lumi=79.9[C],xsec_ggF=101.5[C],xsec_VBF=7.99[C],xsec_VH=4.53[C],xsec_TOP=1.33[C],kF=1,kV=1,nobs_cat0=50000,nobs_cat1=50000,nobs_cat2=50000,nobs_cat3=50000,nobs_cat4=50000,nobs_cat5=50000,nobs_cat6=50000,nobs_cat7=50000,nobs_cat8=50000,nobs_cat9=50000,nobs_cat10=50000,nobs_cat11=50000,nobs_cat12=50000,nobs_cat13=50000,nobs_cat14=50000,nobs_cat15=50000,nobs_cat16=50000,nobs_cat17=50000,nobs_cat18=50000,nobs_cat19=50000,nobs_cat20=50000,nobs_cat21=50000,nobs_cat22=50000,nobs_cat23=50000,nobs_cat24=50000,nobs_cat25=50000,nobs_cat26=50000,nobs_cat27=50000,nobs_cat28=50000,eff_cat0_procggF=0.0759656[C],eff_cat0_procVBF=0.0104605[C],eff_cat0_procVH=0.0145412[C],eff_cat0_procTOP=0.000199324[C],eff_cat1_procggF=0.133594[C],eff_cat1_procVBF=0.0202726[C],eff_cat1_procVH=0.0301054[C],eff_cat1_procTOP=0.000464708[C],eff_cat2_procggF=0.0632723[C],eff_cat2_procVBF=0.0493285[C],eff_cat2_procVH=0.0410382[C],eff_cat2_procTOP=0.00161498[C],eff_cat3_procggF=0.0306302[C],eff_cat3_procVBF=0.0544007[C],eff_cat3_procVH=0.0360506[C],eff_cat3_procTOP=0.0017531[C],eff_cat4_procggF=0.00580298[C],eff_cat4_procVBF=0.0172063[C],eff_cat4_procVH=0.0108921[C],eff_cat4_procTOP=0.000753345[C],eff_cat5_procggF=0.00147099[C],eff_cat5_procVBF=0.00509555[C],eff_cat5_procVH=0.00325223[C],eff_cat5_procTOP=0.000283603[C],eff_cat6_procggF=0.01642[C],eff_cat6_procVBF=0.0234817[C],eff_cat6_procVH=0.0326839[C],eff_cat6_procTOP=0.0200158[C],eff_cat7_procggF=0.0132634[C],eff_cat7_procVBF=0.0265507[C],eff_cat7_procVH=0.0295846[C],eff_cat7_procTOP=0.0205597[C],eff_cat8_procggF=0.00541439[C],eff_cat8_procVBF=0.0115379[C],eff_cat8_procVH=0.0134674[C],eff_cat8_procTOP=0.00845197[C],eff_cat9_procggF=0.00132996[C],eff_cat9_procVBF=0.00226449[C],eff_cat9_procVH=0.00369473[C],eff_cat9_procTOP=0.00283568[C],eff_cat10_procggF=0.00158368[C],eff_cat10_procVBF=0.0377259[C],eff_cat10_procVH=0.000713421[C],eff_cat10_procTOP=0.000579753[C],eff_cat11_procggF=0.000411651[C],eff_cat11_procVBF=0.0359158[C],eff_cat11_procVH=0.000152405[C],eff_cat11_procTOP=0.00040142[C],eff_cat12_procggF=0.00302746[C],eff_cat12_procVBF=0.01239[C],eff_cat12_procVH=0.00390894[C],eff_cat12_procTOP=0.00389614[C],eff_cat13_procggF=0.00246154[C],eff_cat13_procVBF=0.0304512[C],eff_cat13_procVH=0.0030454[C],eff_cat13_procTOP=0.00676058[C],eff_cat14_procggF=0.00255636[C],eff_cat14_procVBF=0.00254553[C],eff_cat14_procVH=0.0221037[C],eff_cat14_procTOP=0.00443349[C],eff_cat15_procggF=0.0014798[C],eff_cat15_procVBF=0.00128219[C],eff_cat15_procVH=0.026869[C],eff_cat15_procTOP=0.00291074[C],eff_cat16_procggF=0.00266558[C],eff_cat16_procVBF=0.0163704[C],eff_cat16_procVH=0.0122852[C],eff_cat16_procTOP=0.0148447[C],eff_cat17_procggF=2.57041e-05[C],eff_cat17_procVBF=2.15495e-05[C],eff_cat17_procVH=0.00294284[C],eff_cat17_procTOP=7.85191e-05[C],eff_cat18_procggF=3.60069e-06[C],eff_cat18_procVBF=5.38736e-06[C],eff_cat18_procVH=0.00629712[C],eff_cat18_procTOP=0.00123834[C],eff_cat19_procggF=0.000140949[C],eff_cat19_procVBF=0.000169702[C],eff_cat19_procVH=0.0241123[C],eff_cat19_procTOP=0.0113398[C],eff_cat20_procggF=0[C],eff_cat20_procVBF=2.69368e-06[C],eff_cat20_procVH=0.00637653[C],eff_cat20_procTOP=0.0043889[C],eff_cat21_procggF=0[C],eff_cat21_procVBF=0[C],eff_cat21_procVH=0.00447888[C],eff_cat21_procTOP=0.000202334[C],eff_cat22_procggF=0.000185505[C],eff_cat22_procVBF=0.000344791[C],eff_cat22_procVH=0.00250042[C],eff_cat22_procTOP=0.0337407[C],eff_cat23_procggF=0.000103138[C],eff_cat23_procVBF=0.000148152[C],eff_cat23_procVH=0.00154299[C],eff_cat23_procTOP=0.0493388[C],eff_cat24_procggF=3.09359e-05[C],eff_cat24_procVBF=4.30989e-05[C],eff_cat24_procVH=0.000513108[C],eff_cat24_procTOP=0.0348397[C],eff_cat25_procggF=1.59987e-05[C],eff_cat25_procVBF=2.33452e-05[C],eff_cat25_procVH=0.000355199[C],eff_cat25_procTOP=0.0424038[C],eff_cat26_procggF=9.96932e-07[C],eff_cat26_procVBF=1.79579e-06[C],eff_cat26_procVH=0.000280457[C],eff_cat26_procTOP=0.00979772[C],eff_cat27_procggF=0[C],eff_cat27_procVBF=8.97894e-07[C],eff_cat27_procVH=0.000205173[C],eff_cat27_procTOP=0.0235937[C],eff_cat28_procggF=0[C],eff_cat28_procVBF=0[C],eff_cat28_procVH=0.000121035[C],eff_cat28_procTOP=0.0455974[C],theta_btag=0,sigma_btag_efficiency_cat0_procggF=0[C],sigma_btag_efficiency_cat0_procVBF=0[C],sigma_btag_efficiency_cat0_procVH=0[C],sigma_btag_efficiency_cat0_procTOP=0[C],sigma_btag_efficiency_cat1_procggF=0[C],sigma_btag_efficiency_cat1_procVBF=0[C],sigma_btag_efficiency_cat1_procVH=0[C],sigma_btag_efficiency_cat1_procTOP=0[C],sigma_btag_efficiency_cat2_procggF=0[C],sigma_btag_efficiency_cat2_procVBF=0[C],sigma_btag_efficiency_cat2_procVH=0[C],sigma_btag_efficiency_cat2_procTOP=0[C],sigma_btag_efficiency_cat3_procggF=0[C],sigma_btag_efficiency_cat3_procVBF=0[C],sigma_btag_efficiency_cat3_procVH=0[C],sigma_btag_efficiency_cat3_procTOP=0[C],sigma_btag_efficiency_cat4_procggF=0[C],sigma_btag_efficiency_cat4_procVBF=0[C],sigma_btag_efficiency_cat4_procVH=0[C],sigma_btag_efficiency_cat4_procTOP=0[C],sigma_btag_efficiency_cat5_procggF=0[C],sigma_btag_efficiency_cat5_procVBF=0[C],sigma_btag_efficiency_cat5_procVH=0[C],sigma_btag_efficiency_cat5_procTOP=0[C],sigma_btag_efficiency_cat6_procggF=0[C],sigma_btag_efficiency_cat6_procVBF=0[C],sigma_btag_efficiency_cat6_procVH=0[C],sigma_btag_efficiency_cat6_procTOP=0[C],sigma_btag_efficiency_cat7_procggF=0[C],sigma_btag_efficiency_cat7_procVBF=0[C],sigma_btag_efficiency_cat7_procVH=0[C],sigma_btag_efficiency_cat7_procTOP=0[C],sigma_btag_efficiency_cat8_procggF=0[C],sigma_btag_efficiency_cat8_procVBF=0[C],sigma_btag_efficiency_cat8_procVH=0[C],sigma_btag_efficiency_cat8_procTOP=0[C],sigma_btag_efficiency_cat9_procggF=0[C],sigma_btag_efficiency_cat9_procVBF=0[C],sigma_btag_efficiency_cat9_procVH=0[C],sigma_btag_efficiency_cat9_procTOP=0[C],sigma_btag_efficiency_cat10_procggF=0[C],sigma_btag_efficiency_cat10_procVBF=0[C],sigma_btag_efficiency_cat10_procVH=0[C],sigma_btag_efficiency_cat10_procTOP=0[C],sigma_btag_efficiency_cat11_procggF=0[C],sigma_btag_efficiency_cat11_procVBF=0[C],sigma_btag_efficiency_cat11_procVH=0[C],sigma_btag_efficiency_cat11_procTOP=0[C],sigma_btag_efficiency_cat12_procggF=0[C],sigma_btag_efficiency_cat12_procVBF=0[C],sigma_btag_efficiency_cat12_procVH=0[C],sigma_btag_efficiency_cat12_procTOP=0[C],sigma_btag_efficiency_cat13_procggF=0[C],sigma_btag_efficiency_cat13_procVBF=0[C],sigma_btag_efficiency_cat13_procVH=0[C],sigma_btag_efficiency_cat13_procTOP=0[C],sigma_btag_efficiency_cat14_procggF=0[C],sigma_btag_efficiency_cat14_procVBF=0[C],sigma_btag_efficiency_cat14_procVH=0[C],sigma_btag_efficiency_cat14_procTOP=0[C],sigma_btag_efficiency_cat15_procggF=0[C],sigma_btag_efficiency_cat15_procVBF=0[C],sigma_btag_efficiency_cat15_procVH=0[C],sigma_btag_efficiency_cat15_procTOP=0[C],sigma_btag_efficiency_cat16_procggF=0[C],sigma_btag_efficiency_cat16_procVBF=0[C],sigma_btag_efficiency_cat16_procVH=0[C],sigma_btag_efficiency_cat16_procTOP=0[C],sigma_btag_efficiency_cat17_procggF=0[C],sigma_btag_efficiency_cat17_procVBF=0[C],sigma_btag_efficiency_cat17_procVH=0[C],sigma_btag_efficiency_cat17_procTOP=0[C],sigma_btag_efficiency_cat18_procggF=0[C],sigma_btag_efficiency_cat18_procVBF=0[C],sigma_btag_efficiency_cat18_procVH=0[C],sigma_btag_efficiency_cat18_procTOP=0[C],sigma_btag_efficiency_cat19_procggF=0[C],sigma_btag_efficiency_cat19_procVBF=0[C],sigma_btag_efficiency_cat19_procVH=0[C],sigma_btag_efficiency_cat19_procTOP=0[C],sigma_btag_efficiency_cat20_procggF=0[C],sigma_btag_efficiency_cat20_procVBF=0[C],sigma_btag_efficiency_cat20_procVH=0[C],sigma_btag_efficiency_cat20_procTOP=0[C],sigma_btag_efficiency_cat21_procggF=0[C],sigma_btag_efficiency_cat21_procVBF=0[C],sigma_btag_efficiency_cat21_procVH=0[C],sigma_btag_efficiency_cat21_procTOP=0[C],sigma_btag_efficiency_cat22_procggF=0.06[C],sigma_btag_efficiency_cat22_procVBF=0.06[C],sigma_btag_efficiency_cat22_procVH=0.06[C],sigma_btag_efficiency_cat22_procTOP=0.06[C],sigma_btag_efficiency_cat23_procggF=0.06[C],sigma_btag_efficiency_cat23_procVBF=0.06[C],sigma_btag_efficiency_cat23_procVH=0.06[C],sigma_btag_efficiency_cat23_procTOP=0.06[C],sigma_btag_efficiency_cat24_procggF=0.06[C],sigma_btag_efficiency_cat24_procVBF=0.06[C],sigma_btag_efficiency_cat24_procVH=0.06[C],sigma_btag_efficiency_cat24_procTOP=0.06[C],sigma_btag_efficiency_cat25_procggF=0.06[C],sigma_btag_efficiency_cat25_procVBF=0.06[C],sigma_btag_efficiency_cat25_procVH=0.06[C],sigma_btag_efficiency_cat25_procTOP=0.06[C],sigma_btag_efficiency_cat26_procggF=0.06[C],sigma_btag_efficiency_cat26_procVBF=0.06[C],sigma_btag_efficiency_cat26_procVH=0.06[C],sigma_btag_efficiency_cat26_procTOP=0.06[C],sigma_btag_efficiency_cat27_procggF=0.06[C],sigma_btag_efficiency_cat27_procVBF=0.06[C],sigma_btag_efficiency_cat27_procVH=0.06[C],sigma_btag_efficiency_cat27_procTOP=0.06[C],sigma_btag_efficiency_cat28_procggF=0.06[C],sigma_btag_efficiency_cat28_procVBF=0.06[C],sigma_btag_efficiency_cat28_procVH=0.06[C],sigma_btag_efficiency_cat28_procTOP=0.06[C],theta_id=0,sigma_id_efficiency_cat0_procggF=0.02[C],sigma_id_efficiency_cat0_procVBF=0.02[C],sigma_id_efficiency_cat0_procVH=0.02[C],sigma_id_efficiency_cat0_procTOP=0.02[C],sigma_id_efficiency_cat1_procggF=0.02[C],sigma_id_efficiency_cat1_procVBF=0.02[C],sigma_id_efficiency_cat1_procVH=0.02[C],sigma_id_efficiency_cat1_procTOP=0.02[C],sigma_id_efficiency_cat2_procggF=0.02[C],sigma_id_efficiency_cat2_procVBF=0.02[C],sigma_id_efficiency_cat2_procVH=0.02[C],sigma_id_efficiency_cat2_procTOP=0.02[C],sigma_id_efficiency_cat3_procggF=0.02[C],sigma_id_efficiency_cat3_procVBF=0.02[C],sigma_id_efficiency_cat3_procVH=0.02[C],sigma_id_efficiency_cat3_procTOP=0.02[C],sigma_id_efficiency_cat4_procggF=0.02[C],sigma_id_efficiency_cat4_procVBF=0.02[C],sigma_id_efficiency_cat4_procVH=0.02[C],sigma_id_efficiency_cat4_procTOP=0.02[C],sigma_id_efficiency_cat5_procggF=0.02[C],sigma_id_efficiency_cat5_procVBF=0.02[C],sigma_id_efficiency_cat5_procVH=0.02[C],sigma_id_efficiency_cat5_procTOP=0.02[C],sigma_id_efficiency_cat6_procggF=0.02[C],sigma_id_efficiency_cat6_procVBF=0.02[C],sigma_id_efficiency_cat6_procVH=0.02[C],sigma_id_efficiency_cat6_procTOP=0.02[C],sigma_id_efficiency_cat7_procggF=0.02[C],sigma_id_efficiency_cat7_procVBF=0.02[C],sigma_id_efficiency_cat7_procVH=0.02[C],sigma_id_efficiency_cat7_procTOP=0.02[C],sigma_id_efficiency_cat8_procggF=0.02[C],sigma_id_efficiency_cat8_procVBF=0.02[C],sigma_id_efficiency_cat8_procVH=0.02[C],sigma_id_efficiency_cat8_procTOP=0.02[C],sigma_id_efficiency_cat9_procggF=0.02[C],sigma_id_efficiency_cat9_procVBF=0.02[C],sigma_id_efficiency_cat9_procVH=0.02[C],sigma_id_efficiency_cat9_procTOP=0.02[C],sigma_id_efficiency_cat10_procggF=0.02[C],sigma_id_efficiency_cat10_procVBF=0.02[C],sigma_id_efficiency_cat10_procVH=0.02[C],sigma_id_efficiency_cat10_procTOP=0.02[C],sigma_id_efficiency_cat11_procggF=0.02[C],sigma_id_efficiency_cat11_procVBF=0.02[C],sigma_id_efficiency_cat11_procVH=0.02[C],sigma_id_efficiency_cat11_procTOP=0.02[C],sigma_id_efficiency_cat12_procggF=0.02[C],sigma_id_efficiency_cat12_procVBF=0.02[C],sigma_id_efficiency_cat12_procVH=0.02[C],sigma_id_efficiency_cat12_procTOP=0.02[C],sigma_id_efficiency_cat13_procggF=0.02[C],sigma_id_efficiency_cat13_procVBF=0.02[C],sigma_id_efficiency_cat13_procVH=0.02[C],sigma_id_efficiency_cat13_procTOP=0.02[C],sigma_id_efficiency_cat14_procggF=0.02[C],sigma_id_efficiency_cat14_procVBF=0.02[C],sigma_id_efficiency_cat14_procVH=0.02[C],sigma_id_efficiency_cat14_procTOP=0.02[C],sigma_id_efficiency_cat15_procggF=0.02[C],sigma_id_efficiency_cat15_procVBF=0.02[C],sigma_id_efficiency_cat15_procVH=0.02[C],sigma_id_efficiency_cat15_procTOP=0.02[C],sigma_id_efficiency_cat16_procggF=0.02[C],sigma_id_efficiency_cat16_procVBF=0.02[C],sigma_id_efficiency_cat16_procVH=0.02[C],sigma_id_efficiency_cat16_procTOP=0.02[C],sigma_id_efficiency_cat17_procggF=0.02[C],sigma_id_efficiency_cat17_procVBF=0.02[C],sigma_id_efficiency_cat17_procVH=0.02[C],sigma_id_efficiency_cat17_procTOP=0.02[C],sigma_id_efficiency_cat18_procggF=0.02[C],sigma_id_efficiency_cat18_procVBF=0.02[C],sigma_id_efficiency_cat18_procVH=0.02[C],sigma_id_efficiency_cat18_procTOP=0.02[C],sigma_id_efficiency_cat19_procggF=0.02[C],sigma_id_efficiency_cat19_procVBF=0.02[C],sigma_id_efficiency_cat19_procVH=0.02[C],sigma_id_efficiency_cat19_procTOP=0.02[C],sigma_id_efficiency_cat20_procggF=0.02[C],sigma_id_efficiency_cat20_procVBF=0.02[C],sigma_id_efficiency_cat20_procVH=0.02[C],sigma_id_efficiency_cat20_procTOP=0.02[C],sigma_id_efficiency_cat21_procggF=0.02[C],sigma_id_efficiency_cat21_procVBF=0.02[C],sigma_id_efficiency_cat21_procVH=0.02[C],sigma_id_efficiency_cat21_procTOP=0.02[C],sigma_id_efficiency_cat22_procggF=0.02[C],sigma_id_efficiency_cat22_procVBF=0.02[C],sigma_id_efficiency_cat22_procVH=0.02[C],sigma_id_efficiency_cat22_procTOP=0.02[C],sigma_id_efficiency_cat23_procggF=0.02[C],sigma_id_efficiency_cat23_procVBF=0.02[C],sigma_id_efficiency_cat23_procVH=0.02[C],sigma_id_efficiency_cat23_procTOP=0.02[C],sigma_id_efficiency_cat24_procggF=0.02[C],sigma_id_efficiency_cat24_procVBF=0.02[C],sigma_id_efficiency_cat24_procVH=0.02[C],sigma_id_efficiency_cat24_procTOP=0.02[C],sigma_id_efficiency_cat25_procggF=0.02[C],sigma_id_efficiency_cat25_procVBF=0.02[C],sigma_id_efficiency_cat25_procVH=0.02[C],sigma_id_efficiency_cat25_procTOP=0.02[C],sigma_id_efficiency_cat26_procggF=0.02[C],sigma_id_efficiency_cat26_procVBF=0.02[C],sigma_id_efficiency_cat26_procVH=0.02[C],sigma_id_efficiency_cat26_procTOP=0.02[C],sigma_id_efficiency_cat27_procggF=0.02[C],sigma_id_efficiency_cat27_procVBF=0.02[C],sigma_id_efficiency_cat27_procVH=0.02[C],sigma_id_efficiency_cat27_procTOP=0.02[C],sigma_id_efficiency_cat28_procggF=0.02[C],sigma_id_efficiency_cat28_procVBF=0.02[C],sigma_id_efficiency_cat28_procVH=0.02[C],sigma_id_efficiency_cat28_procTOP=0.02[C],theta_lumi=0,sigma_lumi_nprod_procggF=0.05[C],sigma_lumi_nprod_procVBF=0.05[C],sigma_lumi_nprod_procVH=0.05[C],sigma_lumi_nprod_procTOP=0.05[C],nexp_bkg_cat0=13000[C],nexp_bkg_cat1=46000[C],nexp_bkg_cat2=19000[C],nexp_bkg_cat3=6900[C],nexp_bkg_cat4=640[C],nexp_bkg_cat5=80[C],nexp_bkg_cat6=7700[C],nexp_bkg_cat7=4100[C],nexp_bkg_cat8=690[C],nexp_bkg_cat9=61[C],nexp_bkg_cat10=280[C],nexp_bkg_cat11=35[C],nexp_bkg_cat12=690[C],nexp_bkg_cat13=320[C],nexp_bkg_cat14=470[C],nexp_bkg_cat15=110[C],nexp_bkg_cat16=610[C],nexp_bkg_cat17=9.8[C],nexp_bkg_cat18=6.5[C],nexp_bkg_cat19=95[C],nexp_bkg_cat20=5.3[C],nexp_bkg_cat21=2.6[C],nexp_bkg_cat22=55[C],nexp_bkg_cat23=33[C],nexp_bkg_cat24=8.2[C],nexp_bkg_cat25=1.4[C],nexp_bkg_cat26=4.7[C],nexp_bkg_cat27=4.9[C],nexp_bkg_cat28=2.2[C],global_lumi=0[C],global_btag=0[C],global_id=0[C])\n", + "\n", + "named sets\n", + "----------\n", + "ModelConfig_GlobalObservables:(global_lumi,global_btag,global_id)\n", + "ModelConfig_NuisParams:(theta_btag,theta_id,theta_lumi)\n", + "ModelConfig_Observables:(nobs_cat0,nobs_cat1,nobs_cat2,nobs_cat3,nobs_cat4,nobs_cat5,nobs_cat6,nobs_cat7,nobs_cat8,nobs_cat9,nobs_cat10,nobs_cat11,nobs_cat12,nobs_cat13,nobs_cat14,nobs_cat15,nobs_cat16,nobs_cat17,nobs_cat18,nobs_cat19,nobs_cat20,nobs_cat21,nobs_cat22,nobs_cat23,nobs_cat24,nobs_cat25,nobs_cat26,nobs_cat27,nobs_cat28)\n", + "ModelConfig_POI:(kF,kV)\n", + "all_exp:(nexp_cat0,nexp_cat1,nexp_cat2,nexp_cat3,nexp_cat4,nexp_cat5,nexp_cat6,nexp_cat7,nexp_cat8,nexp_cat9,nexp_cat10,nexp_cat11,nexp_cat12,nexp_cat13,nexp_cat14,nexp_cat15,nexp_cat16,nexp_cat17,nexp_cat18,nexp_cat19,nexp_cat20,nexp_cat21,nexp_cat22,nexp_cat23,nexp_cat24,nexp_cat25,nexp_cat26,nexp_cat27,nexp_cat28)\n", + "all_obs:(nobs_cat0,nobs_cat1,nobs_cat2,nobs_cat3,nobs_cat4,nobs_cat5,nobs_cat6,nobs_cat7,nobs_cat8,nobs_cat9,nobs_cat10,nobs_cat11,nobs_cat12,nobs_cat13,nobs_cat14,nobs_cat15,nobs_cat16,nobs_cat17,nobs_cat18,nobs_cat19,nobs_cat20,nobs_cat21,nobs_cat22,nobs_cat23,nobs_cat24,nobs_cat25,nobs_cat26,nobs_cat27,nobs_cat28)\n", + "all_signal_expected:(nexp_signal_cat0_procggF,nexp_signal_cat0_procVBF,nexp_signal_cat0_procVH,nexp_signal_cat0_procTOP,nexp_signal_cat1_procggF,nexp_signal_cat1_procVBF,nexp_signal_cat1_procVH,nexp_signal_cat1_procTOP,nexp_signal_cat2_procggF,nexp_signal_cat2_procVBF,nexp_signal_cat2_procVH,nexp_signal_cat2_procTOP,nexp_signal_cat3_procggF,nexp_signal_cat3_procVBF,nexp_signal_cat3_procVH,nexp_signal_cat3_procTOP,nexp_signal_cat4_procggF,nexp_signal_cat4_procVBF,nexp_signal_cat4_procVH,nexp_signal_cat4_procTOP,nexp_signal_cat5_procggF,nexp_signal_cat5_procVBF,nexp_signal_cat5_procVH,nexp_signal_cat5_procTOP,nexp_signal_cat6_procggF,nexp_signal_cat6_procVBF,nexp_signal_cat6_procVH,nexp_signal_cat6_procTOP,nexp_signal_cat7_procggF,nexp_signal_cat7_procVBF,nexp_signal_cat7_procVH,nexp_signal_cat7_procTOP,nexp_signal_cat8_procggF,nexp_signal_cat8_procVBF,nexp_signal_cat8_procVH,nexp_signal_cat8_procTOP,nexp_signal_cat9_procggF,nexp_signal_cat9_procVBF,nexp_signal_cat9_procVH,nexp_signal_cat9_procTOP,nexp_signal_cat10_procggF,nexp_signal_cat10_procVBF,nexp_signal_cat10_procVH,nexp_signal_cat10_procTOP,nexp_signal_cat11_procggF,nexp_signal_cat11_procVBF,nexp_signal_cat11_procVH,nexp_signal_cat11_procTOP,nexp_signal_cat12_procggF,nexp_signal_cat12_procVBF,nexp_signal_cat12_procVH,nexp_signal_cat12_procTOP,nexp_signal_cat13_procggF,nexp_signal_cat13_procVBF,nexp_signal_cat13_procVH,nexp_signal_cat13_procTOP,nexp_signal_cat14_procggF,nexp_signal_cat14_procVBF,nexp_signal_cat14_procVH,nexp_signal_cat14_procTOP,nexp_signal_cat15_procggF,nexp_signal_cat15_procVBF,nexp_signal_cat15_procVH,nexp_signal_cat15_procTOP,nexp_signal_cat16_procggF,nexp_signal_cat16_procVBF,nexp_signal_cat16_procVH,nexp_signal_cat16_procTOP,nexp_signal_cat17_procggF,nexp_signal_cat17_procVBF,nexp_signal_cat17_procVH,nexp_signal_cat17_procTOP,nexp_signal_cat18_procggF,nexp_signal_cat18_procVBF,nexp_signal_cat18_procVH,nexp_signal_cat18_procTOP,nexp_signal_cat19_procggF,nexp_signal_cat19_procVBF,nexp_signal_cat19_procVH,nexp_signal_cat19_procTOP,nexp_signal_cat20_procggF,nexp_signal_cat20_procVBF,nexp_signal_cat20_procVH,nexp_signal_cat20_procTOP,nexp_signal_cat21_procggF,nexp_signal_cat21_procVBF,nexp_signal_cat21_procVH,nexp_signal_cat21_procTOP,nexp_signal_cat22_procggF,nexp_signal_cat22_procVBF,nexp_signal_cat22_procVH,nexp_signal_cat22_procTOP,nexp_signal_cat23_procggF,nexp_signal_cat23_procVBF,nexp_signal_cat23_procVH,nexp_signal_cat23_procTOP,nexp_signal_cat24_procggF,nexp_signal_cat24_procVBF,nexp_signal_cat24_procVH,nexp_signal_cat24_procTOP,nexp_signal_cat25_procggF,nexp_signal_cat25_procVBF,nexp_signal_cat25_procVH,nexp_signal_cat25_procTOP,nexp_signal_cat26_procggF,nexp_signal_cat26_procVBF,nexp_signal_cat26_procVH,nexp_signal_cat26_procTOP,nexp_signal_cat27_procggF,nexp_signal_cat27_procVBF,nexp_signal_cat27_procVH,nexp_signal_cat27_procTOP,nexp_signal_cat28_procggF,nexp_signal_cat28_procVBF,nexp_signal_cat28_procVH,nexp_signal_cat28_procTOP)\n", + "constrains:(constrain_syslumi,constrain_sysbtag,constrain_sysid)\n", + "\n", + "generic objects\n", + "---------------\n", + "RooStats::ModelConfig::ModelConfig\n", + "\n" + ] + } + ], + "source": [ + "ws.Print()" + ] + } + ], + "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 +} diff --git a/tests/test_all.py b/tests/test_all.py index 340cad7..6dce076 100644 --- a/tests/test_all.py +++ b/tests/test_all.py @@ -8,13 +8,40 @@ import ROOT +def test_string_range(): + assert countingworkspace.string_range(2) == ['0', '1'] + + +def test_create_scalar(): + ws = ROOT.RooWorkspace() + countingworkspace.create_scalar(ws, 'lumi', value=10.) + lumi = ws.var('lumi') + assert lumi + assert lumi.isConstant() + assert lumi.getVal() == 10. + + countingworkspace.create_scalar(ws, 'lumi2', value=11., ranges=[1., 20.]) + lumi2 = ws.var('lumi2') + assert lumi2 + assert not lumi2.isConstant() + assert lumi2.getVal() == 11. + assert lumi2.getMin() == 1. + assert lumi2.getMax() == 20. + + countingworkspace.create_scalar(ws, 'expr:double("2*@0", {value})', value=4.) + d = ws.function('double') + assert d + assert d.getVal() == 8. + + def test_create_variable_scalar(): ws = ROOT.RooWorkspace() - countingworkspace.create_variables(ws, 'lumi', values=10.) + r = countingworkspace.create_variables(ws, 'lumi', values=10.) lumi = ws.var('lumi') assert lumi assert lumi.isConstant() assert lumi.getVal() == 10. + assert r.getVal() == 10. countingworkspace.create_variables(ws, 'lumi2', values=11., ranges=[1., 20.]) lumi2 = ws.var('lumi2') @@ -25,13 +52,93 @@ def test_create_variable_scalar(): assert lumi2.getMax() == 20. + countingworkspace.create_variables(ws, 'theta', values=0, ranges=(-5, 5)) + theta = ws.var('theta') + assert theta + assert not theta.isConstant() + assert theta.getVal(0) == 0. + assert theta.getMin() == -5. + assert theta.getMax() == 5. + + +def test_create_variable_vector(): + ws = ROOT.RooWorkspace() + values = [1., 3., 10.] + + r = countingworkspace.create_variables(ws, 'foo_{myindex}', values=values, index_names='myindex') + v = ws.allVars().selectByName('foo_*') + assert(v.getSize() == len(values)) + assert(len(r) == len(values)) + for vv1, vv2, rr in zip(iter_collection(v), values, r): + assert (vv1.getVal() == vv2) + assert (rr.getVal() == vv2) + + + countingworkspace.create_variables(ws, 'bar_{myindex2}', values=values) + v = ws.allVars().selectByName('bar_*') + assert(v.getSize() == len(values)) + for vv1, vv2 in zip(iter_collection(v), values): + assert(vv1.getVal() == vv2) + + countingworkspace.create_variables(ws, 'zoo_{myindex2}', values=values, bins=['one', 'two', 'three']) + v = ws.allVars().selectByName('bar_*') + assert(v.getSize() == len(values)) + for vv1, vv2 in zip(iter_collection(v), values): + assert(vv1.getVal() == vv2) + assert(ws.var('zoo_one').getVal() == values[0]) + assert(ws.var('zoo_two').getVal() == values[1]) + assert(ws.var('zoo_three').getVal() == values[2]) + + bins = list(map(str, range(len(values)))) + countingworkspace.create_variables(ws, 'a_{proc}', bins=bins, values=values, ranges=(-10000, 50000)) + for b, v in zip(bins, values): + a = ws.var('a_%s' % b) + assert a + np.testing.assert_allclose(a.getVal(), v) + np.testing.assert_allclose(a.getMin(), -10000) + np.testing.assert_allclose(a.getMax(), 50000) + + countingworkspace.create_variables(ws, 'x_{proc}', bins=[bins], nbins=(len(bins), ), values=values) + for b, v in zip(bins, values): + x = ws.var('x_%s' % b) + assert x + np.testing.assert_allclose(x.getVal(), v) + + + +def test_create_variable_matrix(): + ws = ROOT.RooWorkspace() + eff = np.arange(6).reshape(2, 3) + r = countingworkspace.create_variables(ws, 'myeff_cat{cat}_proc{proc}', values=eff, index_names=('cat', 'proc')) + assert r + + for r1, v1 in zip(r, eff): + for r2, v2 in zip(r1, v1): + assert r2.getVal() == v2 + + for y in range(2): + for x in range(3): + v = ws.var('myeff_cat{cat}_proc{proc}'.format(cat=y, proc=x)) + assert v + assert v.getVal() == eff[y][x] + + bins_proc = 'A', 'B', 'C' + bins_cat = 'X', 'Y' + countingworkspace.create_variables(ws, 'myeff2_cat{cat}_proc{proc}', values=eff, bins=[bins_cat, bins_proc], index_names=('cat', 'proc')) + for icat, cat in enumerate(bins_cat): + for iproc, proc in enumerate(bins_proc): + v = ws.var('myeff2_cat{cat}_proc{proc}'.format(cat=cat, proc=proc)) + assert v + assert v.getVal() == eff[icat][iproc] + + def test_create_expected_true(): ws = ROOT.RooWorkspace() countingworkspace.create_variables(ws, 'lumi', values=10.) assert ws.var('lumi') NPROC = 4 xsvalues = np.arange(1, NPROC + 1) - countingworkspace.create_variables(ws, 'xsec_{index0}', bins=NPROC, values=xsvalues) + countingworkspace.create_variables(ws, 'xsec_{proc}', nbins=NPROC, values=xsvalues) assert ws.allVars().getSize() == NPROC + 1 @@ -60,14 +167,18 @@ def test_create_formula(): ws = ROOT.RooWorkspace() countingworkspace.create_variables(ws, 'a', values=10.) assert ws.var('a').getVal() == 10. + countingworkspace.create_variables(ws, 'theta', values=0., ranges=(-5, 5)) + assert ws.var('theta').getVal() == 0. + assert ws.var('theta').getMin() == -5. + assert ws.var('theta').getMax() == 5. countingworkspace.create_variables(ws, 'prod:X(a, b[20])') assert ws.var('b').getVal() == 20. assert ws.obj('X').getVal() == 10. * 20. NPROC = 4 xsvalues = np.arange(1, NPROC + 1) - countingworkspace.create_variables(ws, 'xsec_{index0}', bins=NPROC, values=xsvalues) - countingworkspace.create_variables(ws, 'prod:ntrue_{index0}(lumi[100], xsec_{index0})', bins=NPROC) + countingworkspace.create_variables(ws, 'xsec_{proc}', nbins=NPROC, values=xsvalues) + countingworkspace.create_variables(ws, 'prod:ntrue_{proc}(lumi[100], xsec_{proc})', nbins=NPROC) assert ws.obj('ntrue_0').getVal() == 100 * 1 assert ws.obj('ntrue_1').getVal() == 100 * 2 assert ws.obj('ntrue_2').getVal() == 100 * 3 @@ -78,8 +189,8 @@ def test_dot(): ws = ROOT.RooWorkspace() a = np.arange(10) b = np.arange(10) - 1.5 - countingworkspace.create_variables(ws, 'a_{index0}', bins=10, values=a) - countingworkspace.create_variables(ws, 'b_{index0}', bins=10, values=b) + countingworkspace.create_variables(ws, 'a_{index0}', nbins=10, values=a) + countingworkspace.create_variables(ws, 'b_{index0}', nbins=10, values=b) countingworkspace.dot(ws, 'a_{index0}', 'b_{index0}', nvar=10) for i, c in enumerate(a * b): assert ws.obj('a_x_b_%d' % i).getVal() == c @@ -93,8 +204,8 @@ def test_sum(): ws = ROOT.RooWorkspace() a = np.arange(10) b = np.arange(10) - 1.5 - countingworkspace.create_variables(ws, 'a_{index0}', bins=10, values=a) - countingworkspace.create_variables(ws, 'b_{index0}', bins=10, values=b) + countingworkspace.create_variables(ws, 'a_{index0}', nbins=10, values=a) + countingworkspace.create_variables(ws, 'b_{index0}', nbins=10, values=b) countingworkspace.sum(ws, 'a_{index0}', 'b_{index0}', nvar=10) for i, c in enumerate(a + b): assert ws.obj('a_plus_b_%d' % i).getVal() == c @@ -108,13 +219,109 @@ def test_create_workspace(): ws = create_workspace(NCATEGORIES, NPROCESS, NTRUE, EFFICIENCIES, EXPECTED_BKG_CAT) assert ws - for ncat in range(NCATEGORIES): + for cat in range(NCATEGORIES): + for nproc in range(NPROCESS): + np.testing.assert_allclose( + ws.var("eff_cat%d_proc%d" % (cat, nproc)).getVal(), + EFFICIENCIES[cat][nproc], + ) + + all_nexp_cat = np.dot(EFFICIENCIES, NTRUE) + EXPECTED_BKG_CAT + + for cat, nexp_cat in zip(range(NCATEGORIES), all_nexp_cat): + v = ws.obj('nexp_cat{cat}'.format(cat=cat)) + assert(v) + v1 = v.getVal() + np.testing.assert_allclose(v1, nexp_cat) + + model_config = ws.obj('ModelConfig') + obs = model_config.GetObservables() + assert obs + assert obs.getSize() == NCATEGORIES + poi = model_config.GetParametersOfInterest() + assert poi + assert poi.getSize() == NPROCESS + + +def test_create_workspace_systematics_nsignal_gen(): + systematics_nsignal_gen = np.ones(NPROCESS) * 0.01 + systematics_nsignal_gen[0] *= 2 + + ws = create_workspace(NCATEGORIES, NPROCESS, NTRUE, EFFICIENCIES, EXPECTED_BKG_CAT, + systematics_nsignal_gen=[{'name': 'lumi', 'values': systematics_nsignal_gen}]) + + assert ws + for cat in range(NCATEGORIES): for nproc in range(NPROCESS): np.testing.assert_allclose( - ws.var("eff_cat%d_proc%d" % (ncat, nproc)).getVal(), - EFFICIENCIES[ncat][nproc], + ws.var("eff_cat%d_proc%d" % (cat, nproc)).getVal(), + EFFICIENCIES[cat][nproc], ) + all_nexp_cat = np.dot(EFFICIENCIES, NTRUE) + EXPECTED_BKG_CAT + + for cat, nexp_cat in zip(range(NCATEGORIES), all_nexp_cat): + v = ws.obj('nexp_cat{cat}'.format(cat=cat)) + assert(v) + v1 = v.getVal() + np.testing.assert_allclose(v1, nexp_cat) + + ws.var('theta_lumi').setVal(1) + all_nexp_cat = np.dot(EFFICIENCIES, NTRUE * (1. + systematics_nsignal_gen)) + EXPECTED_BKG_CAT + + for cat, nexp_cat in zip(range(NCATEGORIES), all_nexp_cat): + v = ws.obj('nexp_cat{cat}'.format(cat=cat)) + assert(v) + v1 = v.getVal() + np.testing.assert_allclose(v1, nexp_cat) + + ws.var('theta_lumi').setVal(2) + all_nexp_cat = np.dot(EFFICIENCIES, NTRUE * (1. + 2 * systematics_nsignal_gen)) + EXPECTED_BKG_CAT + + for cat, nexp_cat in zip(range(NCATEGORIES), all_nexp_cat): + v = ws.obj('nexp_cat{cat}'.format(cat=cat)) + assert(v) + v1 = v.getVal() + np.testing.assert_allclose(v1, nexp_cat) + + + +def test_create_workspace_systematics_efficiencies(): + systematics_efficiencies = np.ones_like(EFFICIENCIES) * 0.01 + systematics_efficiencies[0] *= 2 + + ws = create_workspace(NCATEGORIES, NPROCESS, NTRUE, EFFICIENCIES, EXPECTED_BKG_CAT, + systematic_efficiencies=[{'name': 'lumi', 'values': systematics_efficiencies}]) + + assert ws + for cat in range(NCATEGORIES): + for nproc in range(NPROCESS): + np.testing.assert_allclose( + ws.var("eff_cat%d_proc%d" % (cat, nproc)).getVal(), + EFFICIENCIES[cat][nproc], + ) + + all_nexp_cat = np.dot(EFFICIENCIES, NTRUE) + EXPECTED_BKG_CAT + + for cat, nexp_cat in zip(range(NCATEGORIES), all_nexp_cat): + v = ws.obj('nexp_cat{cat}'.format(cat=cat)) + assert(v) + v1 = v.getVal() + np.testing.assert_allclose(v1, nexp_cat) + + ws.var('theta_lumi').setVal(2) + all_nexp_cat = np.dot(EFFICIENCIES * (1 + 2 * systematics_efficiencies), NTRUE) + EXPECTED_BKG_CAT + for cat, nexp_cat in zip(range(NCATEGORIES), all_nexp_cat): + v = ws.obj('nexp_cat{cat}'.format(cat=cat)) + assert(v) + v1 = v.getVal() + np.testing.assert_allclose(v1, nexp_cat) + + constrain = ws.pdf('constrain_syslumi') + assert constrain + + + def test_asimov_roostats(): ws = create_workspace(NCATEGORIES, NPROCESS, NTRUE, EFFICIENCIES, EXPECTED_BKG_CAT) obs = ws.set('all_obs') @@ -154,6 +361,8 @@ def test_fit_asimov(): for poi in iter_collection(pois): poi.setVal(poi.getVal() * 1.1) + ws.Print() + fr = pdf.fitTo(data_asimov, ROOT.RooFit.Save()) assert(fr.status() == 0) pois_fitted = fr.floatParsFinal() @@ -161,6 +370,54 @@ def test_fit_asimov(): np.testing.assert_allclose(ntrue, poi_fitted.getVal(), rtol=0.002) +def test_fit_asimov_syst(): + systematics_nsignal_gen = np.ones(NPROCESS) * 0.05 + systematics_nsignal_gen[0] *= 2 + systematics_nsignal_gen2 = np.ones(NPROCESS) * 0.06 + systematics_nsignal_gen2[1] *= 2 + + + ws = create_workspace(NCATEGORIES, NPROCESS, NTRUE, EFFICIENCIES, EXPECTED_BKG_CAT, + systematics_nsignal_gen=[{'name': 'lumi', 'values': systematics_nsignal_gen}, + {'name': 'lumi2', 'values': systematics_nsignal_gen2} + ]) + + obs = ws.set('all_obs') + pdf = ws.obj('model') + assert obs + assert pdf + data_asimov = countingworkspace.utils.generate_asimov(ws) + pois = ws.obj('ModelConfig').GetParametersOfInterest() + assert pois + + # not start the fit from the true values + for poi in iter_collection(pois): + poi.setVal(poi.getVal() * 1.1) + + fr = pdf.fitTo(data_asimov, ROOT.RooFit.Save(), ROOT.RooFit.Hesse(True)) + assert(fr.status() == 0) + pois_fitted = fr.floatParsFinal() + all_errors = [] + for ntrue, poi_fitted in zip(NTRUE, iter_collection(pois_fitted)): + np.testing.assert_allclose(ntrue, poi_fitted.getVal(), rtol=0.002) + all_errors.append(poi_fitted.getError()) + + ws.loadSnapshot('initial') + for theta in iter_collection(ws.allVars().selectByName('theta*')): + theta.setVal(0) + theta.setConstant() + + fr = pdf.fitTo(data_asimov, ROOT.RooFit.Save(), ROOT.RooFit.Hesse(True)) + assert(fr.status() == 0) + pois_fitted = fr.floatParsFinal() + all_errors_stat = [] + for ntrue, poi_fitted in zip(NTRUE, iter_collection(pois_fitted)): + np.testing.assert_allclose(ntrue, poi_fitted.getVal(), rtol=0.002) + all_errors_stat.append(poi_fitted.getError()) + + sys_only_errors = (np.sqrt(np.array(all_errors)**2 - np.array(all_errors_stat)**2) / NTRUE) + np.testing.assert_allclose(sys_only_errors, np.sqrt(systematics_nsignal_gen**2 + systematics_nsignal_gen2**2), rtol=5E-2) + def test_create_workspace_raise(): with pytest.raises(ValueError): create_workspace( @@ -177,53 +434,53 @@ def test_create_workspace_luminosity(): # workspace where nsignal_gen[p] = xsec[p] * lumi ws_with_lumi = ROOT.RooWorkspace() ws_with_lumi.factory('lumi[%f]' % LUMI) - countingworkspace.create_variables(ws_with_lumi, 'xsec_{index0}', - bins=NPROCESS, + countingworkspace.create_variables(ws_with_lumi, 'xsec_{proc}', + nbins=NPROCESS, values=XSECFID_X_BR_PRODUCTION_MODES, ranges=[-1000, 10000]) create_workspace(NCATEGORIES, NPROCESS, None, EFFICIENCIES, EXPECTED_BKG_CAT, - expression_nsignal_gen='prod:nsignal_gen_proc{index0}(lumi, xsec_{index0})', + expression_nsignal_gen='prod:nsignal_gen_proc{proc}(lumi, xsec_{proc})', ws=ws_with_lumi) # workspace where nsignal_gen[p] = mu[p] * xsec[p] * lumi ws_with_4mu = ROOT.RooWorkspace() ws_with_4mu.factory('lumi[%f]' % LUMI) - countingworkspace.create_variables(ws_with_4mu, 'xsec_{index0}', - bins=NPROCESS, + countingworkspace.create_variables(ws_with_4mu, 'xsec_{proc}', + nbins=NPROCESS, values=XSECFID_X_BR_PRODUCTION_MODES) create_workspace(NCATEGORIES, NPROCESS, None, EFFICIENCIES, EXPECTED_BKG_CAT, - expression_nsignal_gen='prod:nsignal_gen_proc{index0}(mu_{index0}[1, -4, 5], lumi, xsec_{index0})', + expression_nsignal_gen='prod:nsignal_gen_proc{proc}(mu_{proc}[1, -4, 5], lumi, xsec_{proc})', ws=ws_with_4mu) # workspace where nsignal_gen[p] = mu * mu[p] * xsec[p] * lumi # where true yield is created externally ws_with_4mu_x_mu = ROOT.RooWorkspace() ws_with_4mu_x_mu.factory('lumi[%f]' % LUMI) - countingworkspace.create_variables(ws_with_4mu_x_mu, 'xsec_{index0}', - bins=NPROCESS, + countingworkspace.create_variables(ws_with_4mu_x_mu, 'xsec_{proc}', + nbins=NPROCESS, values=XSECFID_X_BR_PRODUCTION_MODES) countingworkspace.create_variables(ws_with_4mu_x_mu, - 'prod:nsignal_gen_proc{index0}(mu[1, -4, 5], mu_{index0}[1, -4, 5], lumi, xsec_{index0})', - bins=NPROCESS) + 'prod:nsignal_gen_proc{proc}(mu[1, -4, 5], mu_{proc}[1, -4, 5], lumi, xsec_{proc})', + nbins=NPROCESS) create_workspace(NCATEGORIES, NPROCESS, None, EFFICIENCIES, EXPECTED_BKG_CAT, - expression_nsignal_gen='nsignal_gen_proc{index0}', + expression_nsignal_gen='nsignal_gen_proc{proc}', ws=ws_with_4mu_x_mu) # same, but with names ws_with_4mu_x_mu_names = ROOT.RooWorkspace() ws_with_4mu_x_mu_names.factory('lumi[%f]' % LUMI) - countingworkspace.create_variables(ws_with_4mu_x_mu_names, 'xsec_{index0}', + countingworkspace.create_variables(ws_with_4mu_x_mu_names, 'xsec_{proc}', bins=list(map(str, range(NPROCESS))), values=XSECFID_X_BR_PRODUCTION_MODES) countingworkspace.create_variables(ws_with_4mu_x_mu_names, - 'prod:nsignal_gen_proc{index0}(mu[1, -4, 5], mu_{index0}[1, -4, 5], lumi, xsec_{index0})', + 'prod:nsignal_gen_proc{proc}(mu[1, -4, 5], mu_{proc}[1, -4, 5], lumi, xsec_{proc})', bins=list(map(str, range(NPROCESS)))) create_workspace(list(map(str, range(NCATEGORIES))), list(map(str, range(NPROCESS))), None, EFFICIENCIES, EXPECTED_BKG_CAT, - expression_nsignal_gen='nsignal_gen_proc{index0}', + expression_nsignal_gen='nsignal_gen_proc{proc}', ws=ws_with_4mu_x_mu_names) # nominal workspace for reference