Functions
def	sample2process

def	getcategory

Variables
tuple	log = logging.getLogger(__name__)

dictionary	samples_dict

dictionary	shapes

dictionary	shapes_weight_dict

dictionary	mapping_process2sample

tuple	parser

string	help = "Input directory."

list	default = []

tuple	args = parser.parse_args()

tuple	sample_settings = samples.Samples()

tuple	binnings_settings = binnings.BinningsDict()

tuple	systematics_factory = systematics.SystematicsFactory()

list	plot_configs = []

list	output_files = []

list	hadd_commands = []

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

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

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

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

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

list	looplist = [""]

string	prefix = ""

list	tmp_output_files = []

tuple	output_file = os.path.join(args.output_dir, "htt_%s%s%s.inputs-mssm-13TeV%s.root"%(channel.replace("mm","zmm"),prefix,mass,args.postfix))

tuple	category = categorytemplate.format(mass=mass)

list	exclude_cuts = []

string	cut_type = "mssm2016"

tuple	nominal = (shape_systematic == "nominal")

	list_of_samples = args.samples

string	systematic = "nominal"

string	samples = "\", \""

	channel = channel,

list	additional_weight = shapes_weight_dict[shape_systematic]

tuple	config

string	replacestring = "jecUncNom_tauEsUp"

string	binnings_key = "binningHttMSSM13TeV_"

	histogram_name_template = bkg_histogram_name_templateifnominalelsebkg_syst_histogram_name_template

tuple	PROCESS = sample2process(re.sub("_(os\|ss)_(low\|high)mt","",sample))

tuple	BIN = getcategory(category,sample)

	SYSTEMATIC = systematic

tuple	tmp_output_file

	DST = output_file,

string	SRC = " "

list	debug_plot_configs = []

Function Documentation

def makePlots_datacardsMSSMHtt.getcategory	(	basecategory,
		sample
	)

def makePlots_datacardsMSSMHtt.sample2process ( sample )

Variable Documentation

list makePlots_datacardsMSSMHtt.additional_weight = shapes_weight_dict[shape_systematic]

tuple makePlots_datacardsMSSMHtt.args = parser.parse_args()

tuple makePlots_datacardsMSSMHtt.BIN = getcategory(category,sample)

string makePlots_datacardsMSSMHtt.binnings_key = "binningHttMSSM13TeV_"

tuple makePlots_datacardsMSSMHtt.binnings_settings = binnings.BinningsDict()

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

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

makePlots_datacardsMSSMHtt.category = categorytemplate.format(mass=mass)

makePlots_datacardsMSSMHtt.channel = channel,

tuple makePlots_datacardsMSSMHtt.config

Initial value:

 = sample_settings.get_config(
                                                                 samples=[getattr(samples.Samples, sample) for sample in list_of_samples],
                                                                 channel=channel,
                                                                 category="catHttMSSM13TeV_"+category,
                                                                 weight=args.weight,
                                                                 lumi = args.lumi * 1000,
                                                                 exclude_cuts=args.exclude_cuts,
                                                                 higgs_masses=args.higgs_masses,
                                                                 mssm=True,
                                                                 estimationMethod=args.background_method,
                                                                 controlregions=args.controlregions,
                                                                 fakefactor_method=args.fakefactor_method,
                                                                 cut_type=cut_type,
                                                                 no_ewk_samples = True,
                                                                 no_ewkz_as_dy = True
                                                 )

string makePlots_datacardsMSSMHtt.cut_type = "mssm2016"

list makePlots_datacardsMSSMHtt.debug_plot_configs = []

string makePlots_datacardsMSSMHtt.default = []

makePlots_datacardsMSSMHtt.DST = output_file,

list makePlots_datacardsMSSMHtt.exclude_cuts = []

list makePlots_datacardsMSSMHtt.hadd_commands = []

string makePlots_datacardsMSSMHtt.help = "Input directory."

makePlots_datacardsMSSMHtt.histogram_name_template = bkg_histogram_name_templateifnominalelsebkg_syst_histogram_name_template

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

makePlots_datacardsMSSMHtt.list_of_samples = args.samples

tuple makePlots_datacardsMSSMHtt.log = logging.getLogger(__name__)

makePlots_datacardsMSSMHtt.looplist = [""]

dictionary makePlots_datacardsMSSMHtt.mapping_process2sample

Initial value:

 = {
         "data_obs" : "data",
         "ZTT" : "ztt",
         "ZLL" : "zll",
         "ZL" : "zl",
         "ZJ" : "zj",
         "TT" : "ttj",
         "TTT" : "ttt",
         "TTJ" : "ttjj",
         "VV" : "vv",
         "VVT" : "vvt",
         "VVJ" : "vvj",
         "W" : "wj",
         "QCD" : "qcd",
         "EWK" : "ewk",
         "jetFakes" : "ff",
         "ggH" : "ggh",
         "bbH" : "bbh",
         "qqH" : "qqh",
         "VH" : "vh",
         "WH" : "wh",
         "ZH" : "zh",
 }

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

tuple makePlots_datacardsMSSMHtt.output_file = os.path.join(args.output_dir, "htt_%s%s%s.inputs-mssm-13TeV%s.root"%(channel.replace("mm","zmm"),prefix,mass,args.postfix))

tuple makePlots_datacardsMSSMHtt.output_files = []

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

tuple makePlots_datacardsMSSMHtt.parser

Initial value:

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

2 parents=[logger.loggingParser])

list makePlots_datacardsMSSMHtt.plot_configs = []

string makePlots_datacardsMSSMHtt.prefix = ""

tuple makePlots_datacardsMSSMHtt.PROCESS = sample2process(re.sub("_(os|ss)_(low|high)mt","",sample))

string makePlots_datacardsMSSMHtt.replacestring = "jecUncNom_tauEsUp"

tuple makePlots_datacardsMSSMHtt.sample_settings = samples.Samples()

string makePlots_datacardsMSSMHtt.samples = "\", \""

dictionary makePlots_datacardsMSSMHtt.samples_dict

dictionary makePlots_datacardsMSSMHtt.shapes

dictionary makePlots_datacardsMSSMHtt.shapes_weight_dict

string makePlots_datacardsMSSMHtt.SRC = " "

makePlots_datacardsMSSMHtt.systematic = "nominal"

makePlots_datacardsMSSMHtt.SYSTEMATIC = systematic

tuple makePlots_datacardsMSSMHtt.systematics_factory = systematics.SystematicsFactory()

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

tuple makePlots_datacardsMSSMHtt.tmp_output_file

Initial value:

 = os.path.join(args.output_dir, tmp_input_root_filename_template.replace("$", "").format(
                                                                 ANALYSIS="htt",
                                                                 CHANNEL="zmm" if channel == "mm" else channel,
                                                                 BIN=category.replace("mm","zmm"),
                                                                 SYSTEMATIC=systematic,
                                                                 ERA="13TeV",
                                                                 MASS=prefix+mass
                                                 ))

tuple makePlots_datacardsMSSMHtt.tmp_output_files = []

Functions

Variables

Function Documentation

Variable Documentation