def add_benchmark(self, parameter_values, benchmark_name=None, verbose=True): """ Manually adds an individual benchmark, that is, a parameter point that will be evaluated by MadGraph. If this command is called before Parameters ---------- parameter_values : dict The keys of this dict should be the parameter names and the values the corresponding parameter values. benchmark_name : str or None, optional Name of benchmark. If None, a default name is used. Default value: None. verbose : bool, optional If True, prints output about each benchmark. Default value: True. Returns ------- None Raises ------ RuntimeError If a benchmark with the same name already exists, if parameter_values is not a dict, or if a key of parameter_values does not correspond to a defined parameter. """ # Default names if benchmark_name is None: benchmark_name = "benchmark_" + str(len(self.benchmarks)) # Check input if not isinstance(parameter_values, dict): raise RuntimeError("Parameter values are not a dict: {}".format(parameter_values)) for key, value in six.iteritems(parameter_values): if key not in self.parameters: raise RuntimeError("Unknown parameter: {0}".format(key)) if benchmark_name in self.benchmarks: raise RuntimeError("Benchmark name {} exists already".format(benchmark_name)) # Add benchmark self.benchmarks[benchmark_name] = parameter_values # If first benchmark, this will be the default for sampling if len(self.benchmarks) == 1: self.default_benchmark = benchmark_name if verbose: logger.info("Added benchmark %s: %s)", benchmark_name, format_benchmark(parameter_values)) else: logger.debug("Added benchmark %s: %s)", benchmark_name, format_benchmark(parameter_values))
def _report_setup(self): logger.info("Found %s parameters", self.n_parameters) for key, values in six.iteritems(self.parameters): logger.debug( " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", key, values[0], values[1], values[2], values[3], ) if self.nuisance_parameters is not None: logger.info("Found %s nuisance parameters", self.n_nuisance_parameters) for key, values in six.iteritems(self.nuisance_parameters): logger.debug(" %s (%s)", key, values) else: logger.info("Did not find nuisance parameters") self.include_nuisance_parameters = False logger.info("Found %s benchmarks, of which %s physical", self.n_benchmarks, self.n_benchmarks_phys) for (key, values), is_nuisance in zip(six.iteritems(self.benchmarks), self.benchmark_is_nuisance): if is_nuisance: logger.debug(" %s: systematics", key) else: logger.debug(" %s: %s", key, format_benchmark(values)) logger.info("Found %s observables", self.n_observables) if self.observables is not None: for i, obs in enumerate(self.observables): logger.debug(" %2.2s %s", i, obs) logger.info("Found %s events", self.n_samples) if self.n_events_generated_per_benchmark is not None: for events, name in zip(self.n_events_generated_per_benchmark, six.iterkeys(self.benchmarks)): if events > 0: logger.info(" %s signal events sampled from benchmark %s", events, name) if self.n_events_backgrounds is not None and self.n_events_backgrounds > 0: logger.info(" %s background events", self.n_events_backgrounds) else: logger.debug(" Did not find sample summary information") if self.morpher is not None: logger.info("Found morphing setup with %s components", len(self.morphing_components)) else: logger.info("Did not find morphing setup.") if self.nuisance_morpher is not None: logger.info("Found nuisance morphing setup") else: logger.info("Did not find nuisance morphing setup")
def load(self, filename, disable_morphing=False): """ Loads MadMiner setup from a file. All parameters, benchmarks, and morphing settings are overwritten. See `save` for more details. Parameters ---------- filename : str Path to the MadMiner file. disable_morphing : bool, optional If True, the morphing setup is not loaded from the file. Default value: False. Returns ------- None """ # Load data (self.parameters, self.benchmarks, morphing_components, morphing_matrix, _, _) = load_madminer_settings(filename) logging.info("Found %s parameters:", len(self.parameters)) for key, values in six.iteritems(self.parameters): logging.info( " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", key, values[0], values[1], values[2], values[3], ) logging.info("Found %s benchmarks:", len(self.benchmarks)) for key, values in six.iteritems(self.benchmarks): logging.info(" %s: %s", key, format_benchmark(values)) if self.default_benchmark is None: self.default_benchmark = key # Morphing self.morpher = None self.export_morphing = False if morphing_matrix is not None and morphing_components is not None and not disable_morphing: self.morpher = Morpher(self.parameters) self.morpher.set_components(morphing_components) self.morpher.set_basis(self.benchmarks, morphing_matrix=morphing_matrix) self.export_morphing = True logging.info("Found morphing setup with %s components", len(morphing_components)) else: logging.info("Did not find morphing setup.")
def _report_setup(self): logger.info(f"Found {self.n_parameters} parameters") for i, (key, values) in enumerate(self.parameters.items()): values_str = " / ".join(str(x) for x in values) logger.info(f" {i}: {key} ({values_str})") if self.nuisance_parameters is not None: logger.info(f"Found {self.n_nuisance_parameters} nuisance parameters") for i, (key, values) in enumerate(self.systematics.items()): values_str = " / ".join(str(x) for x in values) logger.info(f" {i}: {key} ({values_str})") else: logger.info("Did not find nuisance parameters") self.include_nuisance_parameters = False logger.info(f"Found {self.n_benchmarks} benchmarks") for (key, values), is_nuisance in zip(self.benchmarks.items(), self.benchmark_is_nuisance): if is_nuisance: logger.debug(" %s: systematics", key) else: logger.debug(" %s: %s", key, format_benchmark(values)) logger.info(f"Found {self.n_observables} observables") if self.observables is not None: for i, obs in enumerate(self.observables): logger.debug(" %2.2s %s", i, obs) logger.info(f"Found {self.n_samples} events") if self.n_events_generated_per_benchmark is not None: for events, name in zip(self.n_events_generated_per_benchmark, self.benchmarks.keys()): if events > 0: logger.info(" %s signal events sampled from benchmark %s", events, name) if self.n_events_backgrounds is not None and self.n_events_backgrounds > 0: logger.info(" %s background events", self.n_events_backgrounds) else: logger.debug(" Did not find sample summary information") if self.morpher is not None: logger.info("Found morphing setup with %s components", len(self.morphing_components)) else: logger.info("Did not find morphing setup.") if self.nuisance_morpher is not None: logger.info("Found nuisance morphing setup") else: logger.info("Did not find nuisance morphing setup")
def __init__(self, filename, disable_morphing=False, include_nuisance_parameters=True): # Save setup self.include_nuisance_parameters = include_nuisance_parameters self.madminer_filename = filename logger.info("Loading data from %s", filename) # Load data ( self.parameters, self.benchmarks, self.benchmark_is_nuisance, self.morphing_components, self.morphing_matrix, self.observables, self.n_samples, _, self.reference_benchmark, self.nuisance_parameters, ) = load_madminer_settings( filename, include_nuisance_benchmarks=include_nuisance_parameters) self.n_parameters = len(self.parameters) self.n_benchmarks = len(self.benchmarks) self.n_benchmarks_phys = np.sum( np.logical_not(self.benchmark_is_nuisance)) self.n_observables = len(self.observables) self.n_nuisance_parameters = 0 if self.nuisance_parameters is not None and include_nuisance_parameters: self.n_nuisance_parameters = len(self.nuisance_parameters) else: self.nuisance_parameters = None logger.info("Found %s parameters", self.n_parameters) for key, values in six.iteritems(self.parameters): logger.debug( " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", key, values[0], values[1], values[2], values[3], ) if self.nuisance_parameters is not None: logger.info("Found %s nuisance parameters", self.n_nuisance_parameters) for key, values in six.iteritems(self.nuisance_parameters): logger.debug(" %s (%s)", key, values) else: logger.info("Did not find nuisance parameters") logger.info("Found %s benchmarks, of which %s physical", self.n_benchmarks, self.n_benchmarks_phys) for (key, values), is_nuisance in zip(six.iteritems(self.benchmarks), self.benchmark_is_nuisance): if is_nuisance: logger.debug(" %s: systematics", key) else: logger.debug(" %s: %s", key, format_benchmark(values)) logger.info("Found %s observables", len(self.observables)) for i, obs in enumerate(self.observables): logger.debug(" %2.2s %s", i, obs) logger.info("Found %s events", self.n_samples) # Morphing self.morpher = None if self.morphing_matrix is not None and self.morphing_components is not None and not disable_morphing: self.morpher = PhysicsMorpher(self.parameters) self.morpher.set_components(self.morphing_components) self.morpher.set_basis(self.benchmarks, morphing_matrix=self.morphing_matrix) logger.info("Found morphing setup with %s components", len(self.morphing_components)) else: logger.info("Did not find morphing setup.") # Nuisance morphing self.nuisance_morpher = None if self.nuisance_parameters is not None: self.nuisance_morpher = NuisanceMorpher( self.nuisance_parameters, list(self.benchmarks.keys()), self.reference_benchmark) logger.info("Found nuisance morphing setup")
def load(self, filename, disable_morphing=False): """ Loads MadMiner setup from a file. All parameters, benchmarks, and morphing settings are overwritten. See `save` for more details. Parameters ---------- filename : str Path to the MadMiner file. disable_morphing : bool, optional If True, the morphing setup is not loaded from the file. Default value: False. Returns ------- None """ # Load data ( self.parameters, self.benchmarks, _, morphing_components, morphing_matrix, _, _, self.systematics, _, _, _, _, self.finite_difference_benchmarks, self.finite_difference_epsilon, ) = load_madminer_settings(filename, include_nuisance_benchmarks=False) logger.info("Found %s parameters:", len(self.parameters)) for key, values in self.parameters.items(): logger.info( " %s (LHA: %s %s, maximal power in squared ME: %s, range: %s)", key, values[0], values[1], values[2], values[3], ) logger.info("Found %s benchmarks:", len(self.benchmarks)) for key, values in self.benchmarks.items(): logger.info(" %s: %s", key, format_benchmark(values)) if self.default_benchmark is None: self.default_benchmark = key # Morphing self.morpher = None self.export_morphing = False if morphing_matrix is not None and morphing_components is not None and not disable_morphing: self.morpher = PhysicsMorpher(self.parameters) self.morpher.set_components(morphing_components) self.morpher.set_basis(self.benchmarks, morphing_matrix=morphing_matrix) self.export_morphing = True logger.info("Found morphing setup with %s components", len(morphing_components)) else: logger.info("Did not find morphing setup.") # Systematics setup if len(self.systematics) == 0: logger.info("Did not find systematics setup.") else: logger.info("Found systematics setup with %s nuisance parameter groups", len(self.systematics)) for key, value in self.systematics.items(): logger.debug(" %s: %s", key, " / ".join(str(x) for x in value))