python.physvalPostProcessingTools Namespace Reference

Classes
class	ConfigManager
class	RebinningOperation
class	EfficiencyComputation
class	ResolutionComputation
class	ROCCurveComputation
class	ProjectionComputation
class	HistogramAddition
class	HistogramAdjustment
class	HistogramBlackList

Functions
	find_histo (root_file, path, should_delete=False)
	— HELPER — ###
	ensure_directory_exists (root_file, path)
	— HELPER — ###
	histogram_paths (directory, prefix="")
	pattern_to_regex (pattern)
	fill_fields (value, fields)
	empty_input (root_file, fragment, fields)
	expand_fragments (fragments, root_file)

Variables
bool	crash_on_error = False
	_FIELD = re.compile(r"\{(\w+)\}")
	— HELPER — ###

Function Documentation

empty_input()

empty_input	(		root_file,
			fragment,
			fields )

Return the first of the named fragment inputs that exists but has no entries.

Definition at line 81 of file physvalPostProcessingTools.py.

def empty_input(root_file, fragment, fields):
    """Return the first of the named fragment inputs that exists but has no entries."""
    for field in [fields] if isinstance(fields, str) else fields:
        histo = root_file.Get(fragment[field])
        if histo and histo.InheritsFrom(ROOT.TH1.Class()) and not histo.GetEntries():
            return fragment[field]
    return None
 

ensure_directory_exists()

ensure_directory_exists	(		root_file,
			path )

— HELPER — ###

Definition at line 38 of file physvalPostProcessingTools.py.

def ensure_directory_exists(root_file, path):
    current = root_file
    for part in path.strip("/").split("/"):
        next_dir = current.Get(part)
        if not next_dir:
            logging.info(f"Saving directory not exist. Creating directory '{part}' in '{current.GetName()}'")
            current.mkdir(part)
        current.cd(part)
        current = ROOT.gDirectory
 

expand_fragments()

expand_fragments	(		fragments,
			root_file )

Resolve the for_each patterns of a domain against the histograms in a file.

A fragment without for_each is kept as it is. One with for_each is repeated
once per histogram matching the pattern, with its {field} placeholders filled
in from the match. skip_if_empty names the inputs that a repetition needs to
be non-empty, which is how the selections a sample does not fill are dropped.

Definition at line 89 of file physvalPostProcessingTools.py.

def expand_fragments(fragments, root_file):
    """Resolve the for_each patterns of a domain against the histograms in a file.
 
    A fragment without for_each is kept as it is. One with for_each is repeated
    once per histogram matching the pattern, with its {field} placeholders filled
    in from the match. skip_if_empty names the inputs that a repetition needs to
    be non-empty, which is how the selections a sample does not fill are dropped.
    """
    paths = None
    expanded = []
    for fragment in fragments:
        pattern = fragment.get("for_each")
        if pattern is None:
            expanded.append(fragment)
            continue
        if paths is None:
            paths = histogram_paths(root_file)
        matches = [match.groupdict() for match in map(pattern_to_regex(pattern).fullmatch, paths) if match]
        if not matches:
            logging.info(f"No histogram matches '{pattern}', nothing to expand")
        for fields in sorted(matches, key=lambda match: sorted(match.items())):
            entry = {key: fill_fields(value, fields) for key, value in fragment.items()
                     if key not in ("for_each", "skip_if_empty")}
            required = fragment.get("skip_if_empty")
            empty = empty_input(root_file, entry, required) if required else None
            if empty:
                logging.info(f"'{empty}' is empty, skipping '{entry['output']}'")
                continue
            expanded.append(entry)
    return expanded
 

fill_fields()

fill_fields	(		value,
			fields )

Substitute the {field} placeholders of one fragment value.

Definition at line 75 of file physvalPostProcessingTools.py.

def fill_fields(value, fields):
    """Substitute the {field} placeholders of one fragment value."""
    if not isinstance(value, str):
        return value
    return _FIELD.sub(lambda field: fields[field.group(1)], value)
 

find_histo()

find_histo	(		root_file,
			path,
			should_delete = False )

— HELPER — ###

Definition at line 11 of file physvalPostProcessingTools.py.

def find_histo(root_file, path, should_delete=False):
    obj = root_file.Get(path)
    if not obj:
        if crash_on_error:
            raise RuntimeError(f"Object not found at path: {path}")
        else:
            logging.warning(f"Object not found at path: {path}")
            return None
    if should_delete:
        # Extract directory and name for deletion
        path_parts = path.strip("/").split("/")
        *dirs, name = path_parts
        current_dir = root_file
        for d in dirs:
            current_dir = current_dir.Get(d)
            if not current_dir: 
                if crash_on_error:
                    raise RuntimeError(f"Directory '{d}' not found in path '{'/'.join(dirs)}' for deletion.")
                else:
                    logging.warning(f"Directory '{d}' not found in path '{'/'.join(dirs)}' for deletion.")
                    return None
        # logging.info(f"Deleting '{name}' in '{'/'.join(dirs)}'")
        current_dir.Delete(f"{name};*")
        return None
    return obj
 

histogram_paths()

histogram_paths	(		directory,
			prefix = "" )

Return the path of every histogram below a directory.

Definition at line 51 of file physvalPostProcessingTools.py.

def histogram_paths(directory, prefix=""):
    """Return the path of every histogram below a directory."""
    paths = []
    for key in directory.GetListOfKeys():
        path = f"{prefix}/{key.GetName()}" if prefix else key.GetName()
        # only the directories are read, so the histograms stay on disk
        stored = ROOT.TClass.GetClass(key.GetClassName())
        if stored.InheritsFrom(ROOT.TDirectory.Class()):
            paths += histogram_paths(key.ReadObj(), path)
        elif stored.InheritsFrom(ROOT.TH1.Class()):
            paths.append(path)
    return paths
 

pattern_to_regex()

pattern_to_regex

(

pattern

)

Turn a pattern with {field} placeholders into a regex with one group per field.

Definition at line 64 of file physvalPostProcessingTools.py.

def pattern_to_regex(pattern):
    """Turn a pattern with {field} placeholders into a regex with one group per field."""
    regex, seen, pos = "", set(), 0
    for field in _FIELD.finditer(pattern):
        name = field.group(1)
        regex += re.escape(pattern[pos:field.start()])
        regex += f"(?P={name})" if name in seen else f"(?P<{name}>[^/]+)"
        seen.add(name)
        pos = field.end()
    return re.compile(regex + re.escape(pattern[pos:]))
 

Variable Documentation

_FIELD

python.physvalPostProcessingTools._FIELD = re.compile(r"\{(\w+)\}")

protected

— HELPER — ###

Definition at line 49 of file physvalPostProcessingTools.py.

crash_on_error

bool python.physvalPostProcessingTools.crash_on_error = False

Definition at line 8 of file physvalPostProcessingTools.py.