Variables
tuple	log = logging.getLogger(__name__)

tuple	parser

string	help = "Input directory."
	parser.add_argument("--two-binning", action="store_true", default=False, help="One small bin in signal region and a large one for the remaining part. [Default:%(default)s]") More...

list	default = ["et", "mt", "tt", "em", "mm"]

tuple	args = parser.parse_args()

	nbins = args.n_bins

tuple	nbins1D = int(nbins**(1.0/len(args.quantities)))

tuple	sample_settings = samples.Samples()

tuple	binnings_settings = binnings.BinningsDict()

tuple	systematics_factory = systematics.SystematicsFactory()

list	plot_configs = []

list	output_files = []

list	merged_output_files = []

list	hadd_commands = []

tuple	datacards = smhttdatacards.SMHttDatacards(higgs_masses=args.higgs_masses,useRateParam=args.use_rateParam,year=args.era)

string	tmp_input_root_filename_template = "input/${ANALYSIS}_${CHANNEL}_${BIN}_${SYSTEMATIC}_${ERA}.root"

string	input_root_filename_template = "input/${ANALYSIS}_${CHANNEL}_${BIN}_${ERA}.root"

string	bkg_histogram_name_template = "${BIN}/${PROCESS}"

string	sig_histogram_name_template = "${BIN}/${PROCESS}${MASS}"

string	bkg_syst_histogram_name_template = "${BIN}/${PROCESS}_${SYSTEMATIC}"

string	sig_syst_histogram_name_template = "${BIN}/${PROCESS}${MASS}_${SYSTEMATIC}"

	datacard_filename_templates = datacards.configs.htt_datacard_filename_templates

string	output_root_filename_template = "datacards/common/${ANALYSIS}.input_${ERA}.root"

list	categories = [channel + "_" + category for category in categories]

tuple	categories_save = sorted(categories)

tuple	datacards_per_channel_category = smhttdatacards.SMHttDatacards(cb=datacards.cb.cp().channel([channel]).bin([category]))

list	exclude_cuts = []

list	higgs_masses = [mass for mass in datacards_per_channel_category.cb.mass_set() if mass != "*"]

tuple	output_file

list	tmp_output_files = []

tuple	nominal = (shape_systematic == "nominal")

list	list_of_samples = [datacards.configs.process2sample(process) for process in list_of_samples]

string	systematic = "nominal"

string	samples = "\", \""

	channel = channel,

	category = category,

tuple	config

tuple	systematics_settings = systematics_factory.get(shape_systematic)

list	qintervals = []

list	subscores = []

string	binnings_key = "binningMVAStudies_"
	if args.two_binning: nbins1D=2 subscores.append("(int({0}>=0.6){1})".format(q, float(int(nbins1Di)))) else: calculate (digit corresponding to q)(digit weight) i.e. More...

list	binnings = binnings_settings.binnings_dict[binnings_key]

	histogram_name_template = bkg_histogram_name_templateifnominalelsebkg_syst_histogram_name_template

tuple	PROCESS = datacards.configs.sample2process(sample)

	BIN = category,

	SYSTEMATIC = systematic

tuple	tmp_output_file

	DST = output_file,

string	SRC = " "

string	merged_input_root_filename_template = "input/${ANALYSIS}_${CHANNEL}.inputs-sm-${ERA}-mvis.root"

tuple	merged_output_file

list	debug_plot_configs = []

	update_systematics = True

tuple	processes = datacards.cb.cp()

float	add_threshold = 0.1

dictionary	datacards_cbs = {}

dictionary	datacards_poi_ranges = {}

tuple	channels = cb.channel_set()

tuple	datacards_workspaces = datacards.text2workspace(datacards_cbs, n_processes=args.n_processes)

tuple	datacards_postfit_shapes = datacards.postfit_shapes_fromworkspace(datacards_cbs, datacards_workspaces, False, args.n_processes, "--sampling" + (" --print" if args.n_processes <= 1 else ""))

Variable Documentation

float makePlots_datacardsSMHtt_nDim.add_threshold = 0.1

tuple makePlots_datacardsSMHtt_nDim.args = parser.parse_args()

makePlots_datacardsSMHtt_nDim.BIN = category,

list makePlots_datacardsSMHtt_nDim.binnings = binnings_settings.binnings_dict[binnings_key]

string makePlots_datacardsSMHtt_nDim.binnings_key = "binningMVAStudies_"

if args.two_binning: nbins1D=2 subscores.append("(int({0}>=0.6)*{1})".format(q, float(int(nbins1D**i)))) else: calculate (digit corresponding to q)*(digit weight) i.e.

int(...)*{4}

tuple makePlots_datacardsSMHtt_nDim.binnings_settings = binnings.BinningsDict()

string makePlots_datacardsSMHtt_nDim.bkg_histogram_name_template = "${BIN}/${PROCESS}"

string makePlots_datacardsSMHtt_nDim.bkg_syst_histogram_name_template = "${BIN}/${PROCESS}_${SYSTEMATIC}"

tuple makePlots_datacardsSMHtt_nDim.categories = [channel + "_" + category for category in categories]

tuple makePlots_datacardsSMHtt_nDim.categories_save = sorted(categories)

makePlots_datacardsSMHtt_nDim.category = category,

makePlots_datacardsSMHtt_nDim.channel = channel,

tuple makePlots_datacardsSMHtt_nDim.channels = cb.channel_set()

tuple makePlots_datacardsSMHtt_nDim.config

Initial value:

 = sample_settings.get_config(
                                                         samples=[getattr(samples.Samples, sample) for sample in list_of_samples],
                                                         channel=channel,
                                                         category="catHtt13TeV_"+category,
                                                         weight=args.weight,
                                                         lumi = args.lumi * 1000,
                                                         exclude_cuts=exclude_cuts,
                                                         higgs_masses=higgs_masses,
                                                         cut_type="baseline2016" if args.era == "2016" else "baseline"
                                         )

makePlots_datacardsSMHtt_nDim.datacard_filename_templates = datacards.configs.htt_datacard_filename_templates

tuple makePlots_datacardsSMHtt_nDim.datacards = smhttdatacards.SMHttDatacards(higgs_masses=args.higgs_masses,useRateParam=args.use_rateParam,year=args.era)

dictionary makePlots_datacardsSMHtt_nDim.datacards_cbs = {}

tuple makePlots_datacardsSMHtt_nDim.datacards_per_channel_category = smhttdatacards.SMHttDatacards(cb=datacards.cb.cp().channel([channel]).bin([category]))

dictionary makePlots_datacardsSMHtt_nDim.datacards_poi_ranges = {}

tuple makePlots_datacardsSMHtt_nDim.datacards_postfit_shapes = datacards.postfit_shapes_fromworkspace(datacards_cbs, datacards_workspaces, False, args.n_processes, "--sampling" + (" --print" if args.n_processes <= 1 else ""))

tuple makePlots_datacardsSMHtt_nDim.datacards_workspaces = datacards.text2workspace(datacards_cbs, n_processes=args.n_processes)

list makePlots_datacardsSMHtt_nDim.debug_plot_configs = []

string makePlots_datacardsSMHtt_nDim.default = ["et", "mt", "tt", "em", "mm"]

makePlots_datacardsSMHtt_nDim.DST = output_file,

list makePlots_datacardsSMHtt_nDim.exclude_cuts = []

list makePlots_datacardsSMHtt_nDim.hadd_commands = []

string makePlots_datacardsSMHtt_nDim.help = "Input directory."

parser.add_argument("--two-binning", action="store_true", default=False, help="One small bin in signal region and a large one for the remaining part. [Default:%(default)s]")

list makePlots_datacardsSMHtt_nDim.higgs_masses = [mass for mass in datacards_per_channel_category.cb.mass_set() if mass != "*"]

makePlots_datacardsSMHtt_nDim.histogram_name_template = bkg_histogram_name_templateifnominalelsebkg_syst_histogram_name_template

string makePlots_datacardsSMHtt_nDim.input_root_filename_template = "input/${ANALYSIS}_${CHANNEL}_${BIN}_${ERA}.root"

list makePlots_datacardsSMHtt_nDim.list_of_samples = [datacards.configs.process2sample(process) for process in list_of_samples]

tuple makePlots_datacardsSMHtt_nDim.log = logging.getLogger(__name__)

string makePlots_datacardsSMHtt_nDim.merged_input_root_filename_template = "input/${ANALYSIS}_${CHANNEL}.inputs-sm-${ERA}-mvis.root"

tuple makePlots_datacardsSMHtt_nDim.merged_output_file

Initial value:

 = os.path.join(args.output_dir, merged_input_root_filename_template.replace("$", "").format(
                                         ANALYSIS="htt",
                                         CHANNEL=channel,
                                         ERA="13TeV"
                         ))

list makePlots_datacardsSMHtt_nDim.merged_output_files = []

makePlots_datacardsSMHtt_nDim.nbins = args.n_bins

int makePlots_datacardsSMHtt_nDim.nbins1D = int(nbins**(1.0/len(args.quantities)))

tuple makePlots_datacardsSMHtt_nDim.nominal = (shape_systematic == "nominal")

tuple makePlots_datacardsSMHtt_nDim.output_file

Initial value:

 = os.path.join(args.output_dir, input_root_filename_template.replace("$", "").format(
                                         ANALYSIS="htt",
                                         CHANNEL=channel,
                                         BIN=category,
                                         ERA="13TeV"
                         ))

tuple makePlots_datacardsSMHtt_nDim.output_files = []

string makePlots_datacardsSMHtt_nDim.output_root_filename_template = "datacards/common/${ANALYSIS}.input_${ERA}.root"

tuple makePlots_datacardsSMHtt_nDim.parser

Initial value:

1 = argparse.ArgumentParser(description="Create ROOT inputs and datacards for SM HTT analysis.",

2 parents=[logger.loggingParser])

list makePlots_datacardsSMHtt_nDim.plot_configs = []

tuple makePlots_datacardsSMHtt_nDim.PROCESS = datacards.configs.sample2process(sample)

tuple makePlots_datacardsSMHtt_nDim.processes = datacards.cb.cp()

list makePlots_datacardsSMHtt_nDim.qintervals = []

tuple makePlots_datacardsSMHtt_nDim.sample_settings = samples.Samples()

string makePlots_datacardsSMHtt_nDim.samples = "\", \""

string makePlots_datacardsSMHtt_nDim.sig_histogram_name_template = "${BIN}/${PROCESS}${MASS}"

string makePlots_datacardsSMHtt_nDim.sig_syst_histogram_name_template = "${BIN}/${PROCESS}${MASS}_${SYSTEMATIC}"

string makePlots_datacardsSMHtt_nDim.SRC = " "

list makePlots_datacardsSMHtt_nDim.subscores = []

makePlots_datacardsSMHtt_nDim.systematic = "nominal"

makePlots_datacardsSMHtt_nDim.SYSTEMATIC = systematic

tuple makePlots_datacardsSMHtt_nDim.systematics_factory = systematics.SystematicsFactory()

tuple makePlots_datacardsSMHtt_nDim.systematics_settings = systematics_factory.get(shape_systematic)

string makePlots_datacardsSMHtt_nDim.tmp_input_root_filename_template = "input/${ANALYSIS}_${CHANNEL}_${BIN}_${SYSTEMATIC}_${ERA}.root"

tuple makePlots_datacardsSMHtt_nDim.tmp_output_file

Initial value:

 = os.path.join(args.output_dir, tmp_input_root_filename_template.replace("$", "").format(
                                                         ANALYSIS="htt",
                                                         CHANNEL=channel,
                                                         BIN=category,
                                                         SYSTEMATIC=systematic,
                                                         ERA="13TeV"
                                         ))

tuple makePlots_datacardsSMHtt_nDim.tmp_output_files = []

makePlots_datacardsSMHtt_nDim.update_systematics = True

Variables

Variable Documentation