Functions
def	replace_observation_by_asimov_dataset

Variables
tuple	log = logging.getLogger(__name__)

tuple	parser

string	help = "Input directory."

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

list	choices = ["individual", "channel", "category", "combined"]

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	merged_output_files = []

list	hadd_commands = []

tuple	datacards = zttpolarisationdatacards.ZttPolarisationDatacards()

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}"

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

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

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

list	datacard_filename_templates = []

tuple	categories = datacards.cb.cp()

tuple	datacards_per_channel_category = zttpolarisationdatacards.ZttPolarisationDatacards(cb=datacards.cb.cp().channel([channel]).bin([category]))

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]

list	asimov_nicks = []

string	systematic = "nominal"

string	samples = "\", \""

	channel = channel,

	category = category,

tuple	config

tuple	systematics_settings = systematics_factory.get(shape_systematic)

string	binnings_key = "binningZttPol13TeV_"

	histogram_name_template = bkg_histogram_name_templateifnominalelsebkg_syst_histogram_name_template

tuple	PROCESS = datacards.configs.sample2process(sample.replace("asimov", "data"))

	BIN = category,

	SYSTEMATIC = systematic

tuple	tmp_output_file

	DST = output_file,

string	SRC = " "

list	debug_plot_configs = []

	update_systematics = True

tuple	processes = datacards.cb.cp()

float	add_threshold = 0.1

tuple	tmp_output_dir = os.path.join(args.output_dir, "" if scaled_lumi is None else ("lumi{:07}pb".format(int(scale_lumi*1000))))

	tmp_www = None

dictionary	polarisation_values_tree_files = {}

tuple	output_dir = os.path.join(tmp_output_dir, "" if asimov_polarisation is None else ("pol{:04}".format(int(asimov_polarisation*1000))))

	www = None

dictionary	datacards_cbs = {}

tuple	datacards_workspaces

	split_stat_syst_uncs = False

tuple	datacards_postfit_shapes

dictionary	plotting_args = {"ratio" : args.ratio, "args" : args.args, "lumi" : args.lumi, "x_expressions" : "tauPolarisationDiscriminatorSvfit", "era" : "2015", "www" : www}

	n_processes = args.n_processes,

	signal_stacked_on_bkg = True

	s_fit_only = True,

list	additional_freeze_nuisances = ["r"]

dictionary	annotation_replacements = {channel : index for (index, channel) in enumerate(["combined"] + args.channel)}

dictionary	values_tree_files = {}

tuple	x_values = sorted([values[0] for values in values_tree_files.keys() if values[0] > -990.0])

dictionary	inv_annotation_replacements = {value : key for key, value in annotation_replacements.iteritems() if (type(key) != int) or (key < 1000)}

tuple	x_values_raw = sorted([values[1] for values in values_tree_files.keys() if values[1] > -990.0])

Function Documentation

def makePlots_datacardsZttPolarisation.replace_observation_by_asimov_dataset	(	datacards,
		pol = `-0.159`,
		r = `1.0`
	)

Variable Documentation

float makePlots_datacardsZttPolarisation.add_threshold = 0.1

list makePlots_datacardsZttPolarisation.additional_freeze_nuisances = ["r"]

dictionary makePlots_datacardsZttPolarisation.annotation_replacements = {channel : index for (index, channel) in enumerate(["combined"] + args.channel)}

tuple makePlots_datacardsZttPolarisation.args = parser.parse_args()

list makePlots_datacardsZttPolarisation.asimov_nicks = []

makePlots_datacardsZttPolarisation.BIN = category,

string makePlots_datacardsZttPolarisation.binnings_key = "binningZttPol13TeV_"

tuple makePlots_datacardsZttPolarisation.binnings_settings = binnings.BinningsDict()

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

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

tuple makePlots_datacardsZttPolarisation.categories = datacards.cb.cp()

makePlots_datacardsZttPolarisation.category = category,

makePlots_datacardsZttPolarisation.channel = channel,

list makePlots_datacardsZttPolarisation.choices = ["individual", "channel", "category", "combined"]

tuple makePlots_datacardsZttPolarisation.config

Initial value:

 = sample_settings.get_config(
                                                         samples=[getattr(samples.Samples, sample) for sample in list_of_samples],
                                                         channel=channel,
                                                         category="catZttPol13TeV_"+category,
                                                         weight=args.weight,
                                                         lumi = args.lumi * 1000,
                                                         higgs_masses=higgs_masses,
                                                         estimationMethod="new",
                                                         polarisation_bias_correction=True,
                                                         cut_type="baseline_low_mvis",
                                                         no_ewk_samples = args.no_ewk_samples,
                                                         no_ewkz_as_dy = True,
                                                         asimov_nicks = asimov_nicks
                                         )

list makePlots_datacardsZttPolarisation.datacard_filename_templates = []

tuple makePlots_datacardsZttPolarisation.datacards = zttpolarisationdatacards.ZttPolarisationDatacards()

dictionary makePlots_datacardsZttPolarisation.datacards_cbs = {}

tuple makePlots_datacardsZttPolarisation.datacards_per_channel_category = zttpolarisationdatacards.ZttPolarisationDatacards(cb=datacards.cb.cp().channel([channel]).bin([category]))

tuple makePlots_datacardsZttPolarisation.datacards_postfit_shapes

Initial value:

 = datacards.postfit_shapes_fromworkspace(
                                                         datacards_cbs,
                                                         datacards_workspaces,
                                                         False,
                                                         args.n_processes,
                                                         "--sampling" + (" --print" if args.n_processes <= 1 else ""),
                                                         #fit_type_list=["fit_mdf"],
                                                         #fit_result="multidimfit.root"
                                         )

tuple makePlots_datacardsZttPolarisation.datacards_workspaces

Initial value:

 = datacards.text2workspace(
                                         datacards_cbs,
                                         args.n_processes,
                                         "-P {MODEL} {MODEL_PARAMETERS}".format(
                                                         MODEL="CombineHarvester.ZTTPOL2016.taupolarisationmodels:ztt_pol",
                                                         MODEL_PARAMETERS=""
                                         )
                         )

list makePlots_datacardsZttPolarisation.debug_plot_configs = []

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

makePlots_datacardsZttPolarisation.DST = output_file,

list makePlots_datacardsZttPolarisation.hadd_commands = []

string makePlots_datacardsZttPolarisation.help = "Input directory."

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

makePlots_datacardsZttPolarisation.histogram_name_template = bkg_histogram_name_templateifnominalelsebkg_syst_histogram_name_template

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

dictionary makePlots_datacardsZttPolarisation.inv_annotation_replacements = {value : key for key, value in annotation_replacements.iteritems() if (type(key) != int) or (key < 1000)}

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

tuple makePlots_datacardsZttPolarisation.log = logging.getLogger(__name__)

list makePlots_datacardsZttPolarisation.merged_output_files = []

makePlots_datacardsZttPolarisation.n_processes = args.n_processes,

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

tuple makePlots_datacardsZttPolarisation.output_dir = os.path.join(tmp_output_dir, "" if asimov_polarisation is None else ("pol{:04}".format(int(asimov_polarisation*1000))))

tuple makePlots_datacardsZttPolarisation.output_file

Initial value:

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

tuple makePlots_datacardsZttPolarisation.output_files = []

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

tuple makePlots_datacardsZttPolarisation.parser

Initial value:

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

2 parents=[logger.loggingParser])

list makePlots_datacardsZttPolarisation.plot_configs = []

dictionary makePlots_datacardsZttPolarisation.plotting_args = {"ratio" : args.ratio, "args" : args.args, "lumi" : args.lumi, "x_expressions" : "tauPolarisationDiscriminatorSvfit", "era" : "2015", "www" : www}

dictionary makePlots_datacardsZttPolarisation.polarisation_values_tree_files = {}

tuple makePlots_datacardsZttPolarisation.PROCESS = datacards.configs.sample2process(sample.replace("asimov", "data"))

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

makePlots_datacardsZttPolarisation.s_fit_only = True,

tuple makePlots_datacardsZttPolarisation.sample_settings = samples.Samples()

string makePlots_datacardsZttPolarisation.samples = "\", \""

string makePlots_datacardsZttPolarisation.sig_histogram_name_template = "${BIN}/${PROCESS}"

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

makePlots_datacardsZttPolarisation.signal_stacked_on_bkg = True

makePlots_datacardsZttPolarisation.split_stat_syst_uncs = False

string makePlots_datacardsZttPolarisation.SRC = " "

makePlots_datacardsZttPolarisation.systematic = "nominal"

makePlots_datacardsZttPolarisation.SYSTEMATIC = systematic

tuple makePlots_datacardsZttPolarisation.systematics_factory = systematics.SystematicsFactory()

tuple makePlots_datacardsZttPolarisation.systematics_settings = systematics_factory.get(shape_systematic)

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

tuple makePlots_datacardsZttPolarisation.tmp_output_dir = os.path.join(args.output_dir, "" if scaled_lumi is None else ("lumi{:07}pb".format(int(scale_lumi*1000))))

tuple makePlots_datacardsZttPolarisation.tmp_output_file

Initial value:

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

tuple makePlots_datacardsZttPolarisation.tmp_output_files = []

tuple makePlots_datacardsZttPolarisation.tmp_www = None

makePlots_datacardsZttPolarisation.update_systematics = True

dictionary makePlots_datacardsZttPolarisation.values_tree_files = {}

tuple makePlots_datacardsZttPolarisation.www = None

list makePlots_datacardsZttPolarisation.x_values = sorted([values[0] for values in values_tree_files.keys() if values[0] > -990.0])

tuple makePlots_datacardsZttPolarisation.x_values_raw = sorted([values[1] for values in values_tree_files.keys() if values[1] > -990.0])

Functions

Variables

Function Documentation

Variable Documentation