Functions
def	add_s_over_sqrtb_subplot

def	add_s_over_sqrtb_integral_subplot

def	blind_signal

Variables
tuple	log = logging.getLogger(__name__)

tuple	parser

string	help = "Input directory."

list	default = ["ztt", "zll", "ttj", "vv", "wj", "qcd", "data"]

tuple	args = parser.parse_args()

list	list_of_samples = [getattr(samples.Samples, sample) for sample in args.samples]

list	asimov_nicks = []

tuple	sample_settings = samples.Samples()

list	bkg_samples = [sample for sample in args.samples if sample not in ["data", "htt", "ggh", "bbh"]]

list	sig_samples_raw = [sample for sample in args.samples if sample in ["htt", "ggh", "bbh"]]

list	sig_samples = []

string	scale_str = "_%i"

tuple	binnings_settings = binnings.BinningsDict()

list	plot_configs = []

string	global_category_string = "catHtt13TeV"

string	global_cut_type = "baseline"

tuple	channels_background_methods = zip(args.channels, args.background_method)

dictionary	channel_config = {}

string	cut_type = "mssm2016full"

tuple	last_loop = len(channels_background_methods)

	category_string = None

dictionary	json_config = {}

list	json_filenames = [os.path.join(args.json_dir, "8TeV" if args.run1 else "13TeV", channel_dir, quantity + ".json") for channel_dir in [channel, "default"]]

tuple	json_filename = os.path.expandvars(json_filename)

tuple	quantity = json_config.pop("x_expressions", [quantity])

tuple	config

tuple	x_expression = json_config.pop("x_expressions", [quantity])

int	sub_conf_index = 0

string	binning_string = "binningHtt13TeV"

string	binnings_key = "{binning_string}{channel}{category}_{quantity}"

	channel = channel,

string	category = "_"

tuple	x_bins = json_config.pop("x_bins", [binnings_key])

tuple	x_binning = re.search("(--x-bins)[\s=\"\'](?P<x_bins>\S)[\"\']?\S", args.args)

list	bkg_samples_used = [nick for nick in bkg_samples if nick in config["nicks"]]

list	scale_nicks_temp = []

list	scale_nicks = []

list	replaced_sig_nicks = []

list	replaced_bkg_nicks = []

	nick = sample

list	sig_samples_used = [nick if nick not in scale_nicks else "%s_Scaled"%nick for nick in replaced_sig_nicks]

string	higgs_temp = "htt125"

list	samples_used = [nick for nick in bkg_samples if nick in config["nicks"]]

list	list_of_config_dicts = [args.args]

	n_processes = args.batch

Function Documentation

def makePlots_controlPlots.add_s_over_sqrtb_integral_subplot	(	config,
		args,
		bkg_samples,
		show_subplot,
		signal_samples
	)

def makePlots_controlPlots.add_s_over_sqrtb_subplot	(	config,
		args,
		bkg_samples,
		show_subplot,
		higgs_nick
	)

def makePlots_controlPlots.blind_signal	(	config,
		blinding_threshold,
		ratio_true
	)

Variable Documentation

tuple makePlots_controlPlots.args = parser.parse_args()

tuple makePlots_controlPlots.asimov_nicks = []

string makePlots_controlPlots.binning_string = "binningHtt13TeV"

string makePlots_controlPlots.binnings_key = "{binning_string}{channel}{category}_{quantity}"

tuple makePlots_controlPlots.binnings_settings = binnings.BinningsDict()

list makePlots_controlPlots.bkg_samples = [sample for sample in args.samples if sample not in ["data", "htt", "ggh", "bbh"]]

list makePlots_controlPlots.bkg_samples_used = [nick for nick in bkg_samples if nick in config["nicks"]]

string makePlots_controlPlots.category = "_"

tuple makePlots_controlPlots.category_string = None

makePlots_controlPlots.channel = channel,

tuple makePlots_controlPlots.channel_config = {}

tuple makePlots_controlPlots.channels_background_methods = zip(args.channels, args.background_method)

makePlots_controlPlots.config

Initial value:

 = sample_settings.get_config(
                                                 samples = list_of_samples,
                                                 channel = channel,
                                                 category = category_string,
                                                 higgs_masses = args.higgs_masses,
                                                 normalise_signal_to_one_pb = False,
                                                 ztt_from_mc = args.ztt_from_mc,
                                                 weight = "((%s)*(%s))" % (json_config.pop("weights", ["1.0"])[0], weight),
                                                 lumi  =  args.lumi * 1000,
                                                 exclude_cuts = args.exclude_cuts + json_config.pop("exclude_cuts", []),
                                                 blind_expression = channel + "_" + quantity,
                                                 fakefactor_method = args.fakefactor_method,
                                                 stack_signal = args.stack_signal,
                                                 scale_signal = args.scale_signal,
                                                 project_to_lumi = args.project_to_lumi,
                                                 cut_mc_only = args.cut_mc_only,
                                                 scale_mc_only = args.scale_mc_only,
                                                 estimationMethod = background_method,
                                                 mssm = args.mssm,
                                                 controlregions = args.controlregions,
                                                 cut_type = global_cut_type,
                                                 no_ewk_samples = args.no_ewk_samples,
                                                 no_ewkz_as_dy = args.no_ewkz_as_dy,
                                                 useRelaxedIsolationForW = args.use_relaxed_isolation_for_W,
                                                 useRelaxedIsolationForQCD = args.use_relaxed_isolation_for_QCD,
                                                 nick_suffix = (channel if args.channel_comparison else ""),
                                                 asimov_nicks = asimov_nicks
                                 )

string makePlots_controlPlots.cut_type = "mssm2016full"

string makePlots_controlPlots.default = ["ztt", "zll", "ttj", "vv", "wj", "qcd", "data"]

string makePlots_controlPlots.global_category_string = "catHtt13TeV"

string makePlots_controlPlots.global_cut_type = "baseline"

string makePlots_controlPlots.help = "Input directory."

string makePlots_controlPlots.higgs_temp = "htt125"

tuple makePlots_controlPlots.json_config = {}

tuple makePlots_controlPlots.json_filename = os.path.expandvars(json_filename)

list makePlots_controlPlots.json_filenames = [os.path.join(args.json_dir, "8TeV" if args.run1 else "13TeV", channel_dir, quantity + ".json") for channel_dir in [channel, "default"]]

tuple makePlots_controlPlots.last_loop = len(channels_background_methods)

list makePlots_controlPlots.list_of_config_dicts = [args.args]

list makePlots_controlPlots.list_of_samples = [getattr(samples.Samples, sample) for sample in args.samples]

tuple makePlots_controlPlots.log = logging.getLogger(__name__)

makePlots_controlPlots.n_processes = args.batch

makePlots_controlPlots.nick = sample

tuple makePlots_controlPlots.parser

Initial value:

1 = argparse.ArgumentParser(description="Make Data-MC control plots.",

2 parents=[logger.loggingParser])

list makePlots_controlPlots.plot_configs = []

makePlots_controlPlots.quantity = json_config.pop("x_expressions", [quantity])

list makePlots_controlPlots.replaced_bkg_nicks = []

list makePlots_controlPlots.replaced_sig_nicks = []

tuple makePlots_controlPlots.sample_settings = samples.Samples()

list makePlots_controlPlots.samples_used = [nick for nick in bkg_samples if nick in config["nicks"]]

list makePlots_controlPlots.scale_nicks = []

list makePlots_controlPlots.scale_nicks_temp = []

string makePlots_controlPlots.scale_str = "_%i"

list makePlots_controlPlots.sig_samples = []

list makePlots_controlPlots.sig_samples_raw = [sample for sample in args.samples if sample in ["htt", "ggh", "bbh"]]

list makePlots_controlPlots.sig_samples_used = [nick if nick not in scale_nicks else "%s_Scaled"%nick for nick in replaced_sig_nicks]

int makePlots_controlPlots.sub_conf_index = 0

tuple makePlots_controlPlots.x_binning = re.search("(--x-bins)[\s=\"\']*(?P<x_bins>\S*)[\"\']?\S", args.args)

tuple makePlots_controlPlots.x_bins = json_config.pop("x_bins", [binnings_key])

tuple makePlots_controlPlots.x_expression = json_config.pop("x_expressions", [quantity])

Functions

Variables

Function Documentation

Variable Documentation