Functions
def	poi_ranges_default

def	poi_ranges_default_bbb

def	poi_ranges_fermion

def	poi_ranges_rf

def	poi_ranges_fermion_bbb

def	poi_ranges_vector

def	poi_ranges_vector_bbb

Variables
tuple	log = logging.getLogger(__name__)

dictionary	models

tuple	parser

string	help = "Datacards."

tuple	choices = models.keys()

tuple	args = parser.parse_args()

list	cv_bins = [float(b) for b in args.cv_bins.split(",")]

list	cf_bins = [float(b) for b in args.cf_bins.split(",")]

list	rv_bins = [float(b) for b in args.rv_bins.split(",")]

list	rf_bins = [float(b) for b in args.rf_bins.split(",")]

tuple	datacards_configs = datacardconfigs.DatacardConfigs()

list	plot_configs = []

tuple	cb = ch.CombineHarvester()

tuple	template_tag = template.split("$")

tuple	matched_template = os.path.join(datacard[:datacard.index(template_tag)], template)

tuple	datacards = smhttdatacards.SMHttDatacards(cb=cb)

tuple	model_settings = models.get(model, {})

dictionary	datacards_workspaces = {}

	output_dir_base = args.output_dir

tuple	sub_dir_base = os.path.join("projection", model, "statUnc" if freeze_syst_uncs else "totUnc")

dictionary	datacards_cbs = {}

dictionary	datacards_poi_ranges = {}

tuple	output_dir = os.path.join(output_dir_base, "{:06}".format(lumi))

tuple	scaled_datacards = smhttdatacards.SMHttDatacards(cb=datacards.cb.deep())

	lumi_scale_factor = lumi/args.lumi_datacards

tuple	scaled_datacards_cbs

tuple	poi_ranges = fit_settings.get("poi_ranges"+("_bbb" if args.with_bbb_uncs else ""), None)

list	json_configs = [jsonTools.JsonDict(os.path.expandvars(json_config_file)).doIncludes().doComments() for json_config_file in fit_settings.get("plots_per_lumi", [])]

tuple	srcs

tuple	dst = src.replace(sub_dir_base.replace("statUnc", "totUnc"), sub_dir_base)

list	text2workspace_args = []

tuple	tmp_physics_option

list	tmp_datacards_workspaces = datacards_workspaces[fit_name]

tuple	tmp_fit_options = fit_options.get("options", "")

tuple	CVCF_BINS = int(cv_bins[0] * cf_bins[0])

list	CV_MIN = cv_bins[1]

list	CV_MAX = cv_bins[2]

list	CF_MIN = cf_bins[1]

list	CF_MAX = cf_bins[2]

tuple	RVRF_BINS = int(rv_bins[0] * rf_bins[0])

list	RV_MIN = rv_bins[1]

list	RV_MAX = rv_bins[2]

list	RF_MIN = rf_bins[1]

list	RF_MAX = rf_bins[2]

string	RMIN = "{RMIN}"

string	RMAX = "{RMAX}"

tuple	method = fit_options.get("method", "MaxLikelihoodFit")

	fit_options = tmp_fit_options,

string	freeze = "--snapshotName {method} -S 0"

	stable = datacards.stable_options,

string	name = "\"\""

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

Function Documentation

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_default ( lumi )

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_default_bbb ( lumi )

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_fermion ( lumi )

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_fermion_bbb ( lumi )

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_rf ( lumi )

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_vector ( lumi )

def makePlots_datacardsSMHtt_limitProjection.poi_ranges_vector_bbb ( lumi )

Variable Documentation

tuple makePlots_datacardsSMHtt_limitProjection.args = parser.parse_args()

tuple makePlots_datacardsSMHtt_limitProjection.cb = ch.CombineHarvester()

list makePlots_datacardsSMHtt_limitProjection.cf_bins = [float(b) for b in args.cf_bins.split(",")]

list makePlots_datacardsSMHtt_limitProjection.CF_MAX = cf_bins[2]

list makePlots_datacardsSMHtt_limitProjection.CF_MIN = cf_bins[1]

tuple makePlots_datacardsSMHtt_limitProjection.choices = models.keys()

list makePlots_datacardsSMHtt_limitProjection.cv_bins = [float(b) for b in args.cv_bins.split(",")]

list makePlots_datacardsSMHtt_limitProjection.CV_MAX = cv_bins[2]

list makePlots_datacardsSMHtt_limitProjection.CV_MIN = cv_bins[1]

tuple makePlots_datacardsSMHtt_limitProjection.CVCF_BINS = int(cv_bins[0] * cf_bins[0])

tuple makePlots_datacardsSMHtt_limitProjection.datacards = smhttdatacards.SMHttDatacards(cb=cb)

dictionary makePlots_datacardsSMHtt_limitProjection.datacards_cbs = {}

tuple makePlots_datacardsSMHtt_limitProjection.datacards_configs = datacardconfigs.DatacardConfigs()

dictionary makePlots_datacardsSMHtt_limitProjection.datacards_poi_ranges = {}

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

tuple makePlots_datacardsSMHtt_limitProjection.datacards_workspaces = {}

tuple makePlots_datacardsSMHtt_limitProjection.dst = src.replace(sub_dir_base.replace("statUnc", "totUnc"), sub_dir_base)

makePlots_datacardsSMHtt_limitProjection.fit_options = tmp_fit_options,

string makePlots_datacardsSMHtt_limitProjection.freeze = "--snapshotName {method} -S 0"

string makePlots_datacardsSMHtt_limitProjection.help = "Datacards."

list makePlots_datacardsSMHtt_limitProjection.json_configs = [jsonTools.JsonDict(os.path.expandvars(json_config_file)).doIncludes().doComments() for json_config_file in fit_settings.get("plots_per_lumi", [])]

tuple makePlots_datacardsSMHtt_limitProjection.log = logging.getLogger(__name__)

makePlots_datacardsSMHtt_limitProjection.lumi_scale_factor = lumi/args.lumi_datacards

tuple makePlots_datacardsSMHtt_limitProjection.matched_template = os.path.join(datacard[:datacard.index(template_tag)], template)

tuple makePlots_datacardsSMHtt_limitProjection.method = fit_options.get("method", "MaxLikelihoodFit")

tuple makePlots_datacardsSMHtt_limitProjection.model_settings = models.get(model, {})

dictionary makePlots_datacardsSMHtt_limitProjection.models

string makePlots_datacardsSMHtt_limitProjection.name = "\"\""

tuple makePlots_datacardsSMHtt_limitProjection.output_dir = os.path.join(output_dir_base, "{:06}".format(lumi))

tuple makePlots_datacardsSMHtt_limitProjection.output_dir_base = args.output_dir

tuple makePlots_datacardsSMHtt_limitProjection.parser

Initial value:

1 = argparse.ArgumentParser(description="Make Projections of the expected limits based on existing datacards.",

2 parents=[logger.loggingParser])

list makePlots_datacardsSMHtt_limitProjection.plot_configs = []

tuple makePlots_datacardsSMHtt_limitProjection.poi_ranges = fit_settings.get("poi_ranges"+("_bbb" if args.with_bbb_uncs else ""), None)

list makePlots_datacardsSMHtt_limitProjection.rf_bins = [float(b) for b in args.rf_bins.split(",")]

list makePlots_datacardsSMHtt_limitProjection.RF_MAX = rf_bins[2]

list makePlots_datacardsSMHtt_limitProjection.RF_MIN = rf_bins[1]

string makePlots_datacardsSMHtt_limitProjection.RMAX = "{RMAX}"

string makePlots_datacardsSMHtt_limitProjection.RMIN = "{RMIN}"

list makePlots_datacardsSMHtt_limitProjection.rv_bins = [float(b) for b in args.rv_bins.split(",")]

list makePlots_datacardsSMHtt_limitProjection.RV_MAX = rv_bins[2]

list makePlots_datacardsSMHtt_limitProjection.RV_MIN = rv_bins[1]

tuple makePlots_datacardsSMHtt_limitProjection.RVRF_BINS = int(rv_bins[0] * rf_bins[0])

tuple makePlots_datacardsSMHtt_limitProjection.scaled_datacards = smhttdatacards.SMHttDatacards(cb=datacards.cb.deep())

tuple makePlots_datacardsSMHtt_limitProjection.scaled_datacards_cbs

Initial value:

 = scaled_datacards.write_datacards(
                                                         os.path.basename(datacard),
                                                         os.path.splitext(os.path.basename(datacard))[0]+"_input.root",
                                                         output_dir
                                         )

tuple makePlots_datacardsSMHtt_limitProjection.srcs

Initial value:

 = os.path.join(
                                                                                 output_dir.replace(sub_dir_base, sub_dir_base.replace("statUnc", "totUnc")),
                                                                                 "higgsCombine{name}.{method}*mH*.root".format(name=fit_name, method=fit_settings.get("method", "MaxLikelihoodFit"))
                                                                 )

makePlots_datacardsSMHtt_limitProjection.stable = datacards.stable_options,

tuple makePlots_datacardsSMHtt_limitProjection.sub_dir_base = os.path.join("projection", model, "statUnc" if freeze_syst_uncs else "totUnc")

tuple makePlots_datacardsSMHtt_limitProjection.template_tag = template.split("$")

list makePlots_datacardsSMHtt_limitProjection.text2workspace_args = []

list makePlots_datacardsSMHtt_limitProjection.tmp_datacards_workspaces = datacards_workspaces[fit_name]

tuple makePlots_datacardsSMHtt_limitProjection.tmp_fit_options = fit_options.get("options", "")

tuple makePlots_datacardsSMHtt_limitProjection.tmp_physics_option

Initial value:

 = physics_option.format(
                                                         CV_MIN=cv_bins[1],
                                                         CV_MAX=cv_bins[2],
                                                         CF_MIN=cf_bins[1],
                                                         CF_MAX=cf_bins[2],
                                                         RV_MIN=rv_bins[1],
                                                         RV_MAX=rv_bins[2],
                                                         RF_MIN=rf_bins[1],
                                                         RF_MAX=rf_bins[2]
                                         )

Functions

Variables

Function Documentation

Variable Documentation