From 1cad32383c604efe9693e72b1ce4972c95957a48 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Thu, 16 Oct 2025 12:54:59 +0200 Subject: [PATCH 01/16] Working version of conditionally_skip script --- .pre-commit-config.yaml | 11 + scripts/wrap_pid_conditions.py | 390 +++++++++++++++++++++++++++++++++ 2 files changed, 401 insertions(+) create mode 100755 scripts/wrap_pid_conditions.py diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 1bb97b58dfc..0ad32462bf4 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -29,3 +29,14 @@ repos: hooks: - id: lb-add-copyright exclude: "^lhcbproject.yml$" +- repo: local + hooks: + - id: wrap-pid-conditions + name: Wrap PID cuts with conditionally_skip + ensure import + entry: python3 scripts/wrap_pid_conditions.py + language: system + types: [python] + pass_filenames: true + additional_dependencies: [] + # To fail CI without auto-fixing, switch to: + # entry: python3 scripts/wrap_pid_conditions.py --check diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py new file mode 100755 index 00000000000..e5ab801e7eb --- /dev/null +++ b/scripts/wrap_pid_conditions.py @@ -0,0 +1,390 @@ +#!/usr/bin/env python3 +############################################################################### +# (c) Copyright 2025 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### +from __future__ import annotations + +import argparse +import re +import sys +from pathlib import Path + +import libcst as cst + +# ================================ +# Config +# ================================ + +PID_ATTR_RE = re.compile(r"^(PID|PROBNN)_", re.IGNORECASE) +PID_BOOL_NAMES = {"ISMUON"} + +PID_WRAPPER_FUNCS = { + "CHILD", + "MIN", + "MAX", + "SUM", + "ANY", + "ALL", + "MINTREE", + "MAXTREE", + "in_range", +} + +BOOL_CONSUMERS = {"SUM", "ANY", "ALL", "COUNT"} + +# ================================ +# Helpers +# ================================ + + +def is_F_attr(node: cst.CSTNode) -> bool: + return ( + isinstance(node, cst.Attribute) + and isinstance(node.value, cst.Name) + and node.value.value == "F" + and isinstance(node.attr, cst.Name) + ) + + +def attr_value(node: cst.Attribute) -> str: + return node.attr.value # type: ignore[return-value] + + +def is_pid_attribute(node: cst.CSTNode) -> bool: + if not is_F_attr(node): + return False + name = attr_value(node) + return bool(PID_ATTR_RE.match(name)) or (name in PID_BOOL_NAMES) + + +def is_pid_wrapper_call(node: cst.CSTNode) -> bool: + if not isinstance(node, cst.Call): + return False + f = node.func + if is_F_attr(f): + return attr_value(f) in PID_WRAPPER_FUNCS + return False + + +def func_name_like(node: cst.CSTNode) -> str | None: + if isinstance(node, cst.Name): + return node.value + if is_F_attr(node): + return attr_value(node) + if isinstance(node, cst.Attribute) and isinstance(node.attr, cst.Name): + return node.attr.value + return None + + +def contains_pid_marker(node: cst.CSTNode) -> bool: + found = False + + class Finder(cst.CSTVisitor): + def visit_Attribute(self, n: cst.Attribute) -> None: + nonlocal found + if found: + return + if is_pid_attribute(n): + found = True + + def visit_Call(self, n: cst.Call) -> None: + nonlocal found + if found: + return + if is_pid_wrapper_call(n): + for a in n.args: + if a.value is not None and contains_pid_marker(a.value): + found = True + + node.visit(Finder()) + return found + + +def is_conditionally_skip_call(node: cst.CSTNode) -> bool: + return ( + isinstance(node, cst.Call) + and isinstance(node.func, cst.Name) + and node.func.value == "conditionally_skip" + ) + + +def is_boolean_like(node: cst.CSTNode) -> bool: + if is_pid_attribute(node): + return attr_value(node) in PID_BOOL_NAMES + if isinstance(node, cst.UnaryOperation) and isinstance( + node.operator, cst.BitInvert + ): + return is_boolean_like(node.expression) + return False + + +# ================================ +# Transformer: wrap PID cuts +# ================================ + + +class WrapPidCuts(cst.CSTTransformer): + def __init__(self): + self._in_cond_skip_stack: list[bool] = [] + self.introduced_count: int = 0 + + def _wrap(self, expr: cst.BaseExpression) -> cst.Call: + self.introduced_count += 1 + return cst.Call(func=cst.Name("conditionally_skip"), args=[cst.Arg(expr)]) + + def visit_Call(self, node: cst.Call) -> None: + self._in_cond_skip_stack.append(is_conditionally_skip_call(node)) + + def leave_Call( + self, original_node: cst.Call, updated_node: cst.Call + ) -> cst.BaseExpression: + _ = self._in_cond_skip_stack.pop() if self._in_cond_skip_stack else False + fn = func_name_like(updated_node.func) or "" + if is_F_attr(updated_node.func) and (fn in BOOL_CONSUMERS): + new_args = [] + for a in updated_node.args: + v = a.value + if ( + isinstance(v, cst.Comparison) + and contains_pid_marker(v) + and not is_conditionally_skip_call(v) + ): + v = self._wrap(v) + new_args.append(a.with_changes(value=v)) + return updated_node.with_changes(args=new_args) + return updated_node + + def leave_Comparison( + self, original_node: cst.Comparison, updated_node: cst.Comparison + ) -> cst.BaseExpression: + if any(self._in_cond_skip_stack): + return updated_node + if contains_pid_marker(updated_node): + return self._wrap(updated_node) + return updated_node + + def leave_UnaryOperation( + self, original_node: cst.UnaryOperation, updated_node: cst.UnaryOperation + ) -> cst.BaseExpression: + if any(self._in_cond_skip_stack): + return updated_node + if isinstance(updated_node.operator, cst.BitInvert): + opnd = updated_node.expression + if (isinstance(opnd, cst.Comparison) and contains_pid_marker(opnd)) or ( + contains_pid_marker(opnd) and is_boolean_like(opnd) + ): + return self._wrap(updated_node) + return updated_node + + def leave_BinaryOperation( + self, original_node: cst.BinaryOperation, updated_node: cst.BinaryOperation + ) -> cst.BaseExpression: + if isinstance(updated_node.operator, (cst.BitAnd, cst.BitOr)): + + def maybe_wrap(e: cst.BaseExpression) -> cst.BaseExpression: + if is_conditionally_skip_call(e): + return e + if isinstance(e, cst.Comparison) and contains_pid_marker(e): + return self._wrap(e) + if isinstance(e, cst.UnaryOperation) and isinstance( + e.operator, cst.BitInvert + ): + inner = e.expression + if ( + isinstance(inner, cst.Comparison) and contains_pid_marker(inner) + ) or (contains_pid_marker(inner) and is_boolean_like(inner)): + return self._wrap(e) + return e + + return updated_node.with_changes( + left=maybe_wrap(updated_node.left), + right=maybe_wrap(updated_node.right), + ) + return updated_node + + +# ================================ +# Transformer: ensure import +# ================================ + + +class EnsureConditionallySkipImport(cst.CSTTransformer): + """ + Ensure: from RecoConf.global_tools import conditionally_skip + Only acts if `should_apply` is True. + Fixes: + - no brittle string guard + - handle names as Sequence[ImportAlias] (tuple) instead of list + """ + + def __init__(self, should_apply: bool): + self.should_apply = should_apply + self.injected_or_found = False + self.added_to_existing = False + self.insert_after_index = 0 + + def _is_target_module(self, module: cst.CSTNode | None) -> bool: + return ( + isinstance(module, cst.Attribute) + and isinstance(module.value, cst.Name) + and module.value.value == "RecoConf" + and isinstance(module.attr, cst.Name) + and module.attr.value == "global_tools" + ) + + def visit_Module(self, node: cst.Module) -> None: + idx = 0 + body = node.body + # after module docstring + if body and isinstance(body[0], cst.SimpleStatementLine): + stmt = body[0] + if ( + len(stmt.body) == 1 + and isinstance(stmt.body[0], cst.Expr) + and isinstance(stmt.body[0].value, cst.SimpleString) + ): + idx = 1 + # after __future__ imports + while idx < len(body): + stmt = body[idx] + if ( + isinstance(stmt, cst.SimpleStatementLine) + and stmt.body + and isinstance(stmt.body[0], cst.ImportFrom) + ): + imp: cst.ImportFrom = stmt.body[0] + if ( + isinstance(imp.module, cst.Name) + and imp.module.value == "__future__" + ): + idx += 1 + continue + break + self.insert_after_index = idx + + def leave_ImportFrom( + self, original_node: cst.ImportFrom, updated_node: cst.ImportFrom + ) -> cst.ImportFrom: + # If ANY import-from brings conditionally_skip into scope, mark as found (don’t inject again) + names = updated_node.names + if isinstance(names, cst.ImportStar): + # Star import from *anywhere* could already provide the name; be conservative: + if self._is_target_module(updated_node.module): + self.injected_or_found = True + return updated_node + + if isinstance(names, tuple): + for n in names: + if isinstance(n, cst.ImportAlias): + if ( + isinstance(n.name, cst.Name) + and n.name.value == "conditionally_skip" + ): + self.injected_or_found = True + + # If it's specifically from RecoConf.global_tools, append the alias if missing + if self.should_apply and self._is_target_module(updated_node.module): + if isinstance(names, tuple): + have = any( + isinstance(n, cst.ImportAlias) + and isinstance(n.name, cst.Name) + and n.name.value == "conditionally_skip" + for n in names + ) + if not have: + new_names = list(names) + [ + cst.ImportAlias(name=cst.Name("conditionally_skip")) + ] + self.added_to_existing = True + self.injected_or_found = True + return updated_node.with_changes(names=tuple(new_names)) + + return updated_node + + def leave_Module( + self, original_node: cst.Module, updated_node: cst.Module + ) -> cst.Module: + if not self.should_apply: + return updated_node + if self.injected_or_found: + return updated_node + # Insert a fresh import line + new_import = cst.SimpleStatementLine( + body=[ + cst.ImportFrom( + module=cst.Attribute( + value=cst.Name("RecoConf"), attr=cst.Name("global_tools") + ), + names=(cst.ImportAlias(name=cst.Name("conditionally_skip")),), + ) + ] + ) + body = list(updated_node.body) + i = min(self.insert_after_index, len(body)) + body.insert(i, new_import) + return updated_node.with_changes(body=body) + + +# ================================ +# Driver +# ================================ + + +def process_file(path: Path, write: bool) -> bool: + try: + code = path.read_text(encoding="utf-8") + except Exception: + return False + try: + mod = cst.parse_module(code) + except Exception: + return False + + # Pass 1: wrap PID cuts + wrapper = WrapPidCuts() + mod1 = mod.visit(wrapper) + + # Pass 2: ensure import only if we introduced any wrappers + mod2 = mod1.visit( + EnsureConditionallySkipImport(should_apply=(wrapper.introduced_count > 0)) + ) + + changed = mod2.code != code + if changed and write: + path.write_text(mod2.code, encoding="utf-8") + return changed + + +def main(): + ap = argparse.ArgumentParser( + description="Wrap PID cuts with conditionally_skip(...) and ensure proper import." + ) + ap.add_argument("files", nargs="+", help=".py files to process") + ap.add_argument( + "--check", + action="store_true", + help="Only check; exit 1 if changes would be made", + ) + args = ap.parse_args() + + any_changed = False + for f in args.files: + p = Path(f) + if p.suffix != ".py" or not p.is_file(): + continue + if process_file(p, write=not args.check): + any_changed = True + + if args.check and any_changed: + sys.exit(1) + + +if __name__ == "__main__": + main() -- GitLab From ca112c25f50bacc73b09e7345ead34d0de6ce036 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Thu, 16 Oct 2025 14:35:15 +0200 Subject: [PATCH 02/16] Add GHOSTPROB functor --- scripts/wrap_pid_conditions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py index e5ab801e7eb..db7035bbfcb 100755 --- a/scripts/wrap_pid_conditions.py +++ b/scripts/wrap_pid_conditions.py @@ -22,7 +22,7 @@ import libcst as cst # Config # ================================ -PID_ATTR_RE = re.compile(r"^(PID|PROBNN)_", re.IGNORECASE) +PID_ATTR_RE = re.compile(r"^((PID|PROBNN)_|GHOSTPROB)", re.IGNORECASE) PID_BOOL_NAMES = {"ISMUON"} PID_WRAPPER_FUNCS = { -- GitLab From d5bdffd7aeef3d000821202dda81ac5318e3e7d6 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Thu, 16 Oct 2025 14:42:06 +0200 Subject: [PATCH 03/16] Add support for derived pid variables --- scripts/wrap_pid_conditions.py | 113 ++++++++++++++++++++++++++++----- 1 file changed, 96 insertions(+), 17 deletions(-) diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py index db7035bbfcb..9b1a26d2ce5 100755 --- a/scripts/wrap_pid_conditions.py +++ b/scripts/wrap_pid_conditions.py @@ -107,6 +107,28 @@ def contains_pid_marker(node: cst.CSTNode) -> bool: return found +def contains_pid_or_derived(node: cst.CSTNode, derived: set[str]) -> bool: + """ + True if the subtree contains a PID marker (F.PID_*, F.PROBNN_*, F.GHOSTPROB, etc.) + OR references any name already marked as PID-derived. + """ + if contains_pid_marker(node): + return True + + found = False + + class FindDerived(cst.CSTVisitor): + def visit_Name(self, n: cst.Name) -> None: + nonlocal found + if found: + return + if n.value in derived: + found = True + + node.visit(FindDerived()) + return found + + def is_conditionally_skip_call(node: cst.CSTNode) -> bool: return ( isinstance(node, cst.Call) @@ -125,15 +147,62 @@ def is_boolean_like(node: cst.CSTNode) -> bool: return False +# ================================ +# Pre-pass: collect PID-derived names +# ================================ + + +class CollectPidDerivedNames(cst.CSTVisitor): + """ + Builds a set of simple names assigned from PID-bearing expressions, + and propagates through reassignments/aug-assignments. + + Tracks only simple names (e.g. x = ...), not attributes (self.x) or destructuring. + """ + + def __init__(self): + self.derived: set[str] = set() + + def _expr_is_pid_related(self, expr: cst.BaseExpression) -> bool: + return contains_pid_or_derived(expr, self.derived) + + def visit_Assign(self, node: cst.Assign) -> None: + # a = or a = b = + if node.value is None: + return + if not self._expr_is_pid_related(node.value): + return + for t in node.targets: + if isinstance(t.target, cst.Name): + self.derived.add(t.target.value) + + def visit_AnnAssign(self, node: cst.AnnAssign) -> None: + # a: T = + if node.value is None: + return + if not self._expr_is_pid_related(node.value): + return + if isinstance(node.target, cst.Name): + self.derived.add(node.target.value) + + def visit_AugAssign(self, node: cst.AugAssign) -> None: + # a *= , a += , etc. (mark 'a' if RHS is PID-related) + if not self._expr_is_pid_related(node.value): + return + if isinstance(node.target, cst.Name): + self.derived.add(node.target.value) + + # ================================ # Transformer: wrap PID cuts # ================================ class WrapPidCuts(cst.CSTTransformer): - def __init__(self): + def __init__(self, derived_names: set[str]): self._in_cond_skip_stack: list[bool] = [] self.introduced_count: int = 0 + self.derived = set(derived_names) def _wrap(self, expr: cst.BaseExpression) -> cst.Call: self.introduced_count += 1 @@ -153,7 +222,7 @@ class WrapPidCuts(cst.CSTTransformer): v = a.value if ( isinstance(v, cst.Comparison) - and contains_pid_marker(v) + and contains_pid_or_derived(v, self.derived) and not is_conditionally_skip_call(v) ): v = self._wrap(v) @@ -166,7 +235,7 @@ class WrapPidCuts(cst.CSTTransformer): ) -> cst.BaseExpression: if any(self._in_cond_skip_stack): return updated_node - if contains_pid_marker(updated_node): + if contains_pid_or_derived(updated_node, self.derived): return self._wrap(updated_node) return updated_node @@ -177,8 +246,11 @@ class WrapPidCuts(cst.CSTTransformer): return updated_node if isinstance(updated_node.operator, cst.BitInvert): opnd = updated_node.expression - if (isinstance(opnd, cst.Comparison) and contains_pid_marker(opnd)) or ( - contains_pid_marker(opnd) and is_boolean_like(opnd) + if ( + isinstance(opnd, cst.Comparison) + and contains_pid_or_derived(opnd, self.derived) + ) or ( + contains_pid_or_derived(opnd, self.derived) and is_boolean_like(opnd) ): return self._wrap(updated_node) return updated_node @@ -191,15 +263,21 @@ class WrapPidCuts(cst.CSTTransformer): def maybe_wrap(e: cst.BaseExpression) -> cst.BaseExpression: if is_conditionally_skip_call(e): return e - if isinstance(e, cst.Comparison) and contains_pid_marker(e): + if isinstance(e, cst.Comparison) and contains_pid_or_derived( + e, self.derived + ): return self._wrap(e) if isinstance(e, cst.UnaryOperation) and isinstance( e.operator, cst.BitInvert ): inner = e.expression if ( - isinstance(inner, cst.Comparison) and contains_pid_marker(inner) - ) or (contains_pid_marker(inner) and is_boolean_like(inner)): + isinstance(inner, cst.Comparison) + and contains_pid_or_derived(inner, self.derived) + ) or ( + contains_pid_or_derived(inner, self.derived) + and is_boolean_like(inner) + ): return self._wrap(e) return e @@ -219,9 +297,7 @@ class EnsureConditionallySkipImport(cst.CSTTransformer): """ Ensure: from RecoConf.global_tools import conditionally_skip Only acts if `should_apply` is True. - Fixes: - - no brittle string guard - - handle names as Sequence[ImportAlias] (tuple) instead of list + Handles both single-line and parenthesized multi-line import-from statements. """ def __init__(self, should_apply: bool): @@ -272,10 +348,9 @@ class EnsureConditionallySkipImport(cst.CSTTransformer): def leave_ImportFrom( self, original_node: cst.ImportFrom, updated_node: cst.ImportFrom ) -> cst.ImportFrom: - # If ANY import-from brings conditionally_skip into scope, mark as found (don’t inject again) + # If ANY import-from brings conditionally_skip into scope, mark as found names = updated_node.names if isinstance(names, cst.ImportStar): - # Star import from *anywhere* could already provide the name; be conservative: if self._is_target_module(updated_node.module): self.injected_or_found = True return updated_node @@ -289,7 +364,7 @@ class EnsureConditionallySkipImport(cst.CSTTransformer): ): self.injected_or_found = True - # If it's specifically from RecoConf.global_tools, append the alias if missing + # Append to `from RecoConf.global_tools import ...` if missing if self.should_apply and self._is_target_module(updated_node.module): if isinstance(names, tuple): have = any( @@ -347,8 +422,12 @@ def process_file(path: Path, write: bool) -> bool: except Exception: return False - # Pass 1: wrap PID cuts - wrapper = WrapPidCuts() + # Pre-pass: collect PID-derived names + collector = CollectPidDerivedNames() + mod.visit(collector) + + # Pass 1: wrap PID cuts (including expressions using derived names) + wrapper = WrapPidCuts(derived_names=collector.derived) mod1 = mod.visit(wrapper) # Pass 2: ensure import only if we introduced any wrappers @@ -364,7 +443,7 @@ def process_file(path: Path, write: bool) -> bool: def main(): ap = argparse.ArgumentParser( - description="Wrap PID cuts with conditionally_skip(...) and ensure proper import." + description="Wrap PID cuts with conditionally_skip(...), including expressions using PID-derived variables, and ensure proper import." ) ap.add_argument("files", nargs="+", help=".py files to process") ap.add_argument( -- GitLab From b6072eeeab9bf730d6fa22a6a4a340535090100f Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Tue, 21 Oct 2025 08:05:14 +0200 Subject: [PATCH 04/16] Replace GHOSTPROB with IS_PHOTON and IS_NOT_H --- scripts/wrap_pid_conditions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py index 9b1a26d2ce5..2b5c8604f6c 100755 --- a/scripts/wrap_pid_conditions.py +++ b/scripts/wrap_pid_conditions.py @@ -22,7 +22,7 @@ import libcst as cst # Config # ================================ -PID_ATTR_RE = re.compile(r"^((PID|PROBNN)_|GHOSTPROB)", re.IGNORECASE) +PID_ATTR_RE = re.compile(r"^((PID|PROBNN)_|IS_PHOTON|IS_NOT_H)", re.IGNORECASE) PID_BOOL_NAMES = {"ISMUON"} PID_WRAPPER_FUNCS = { -- GitLab From 44e390526063b80a6df8cb9ecd30f4887c9e563d Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Mon, 1 Dec 2025 11:11:58 +0100 Subject: [PATCH 05/16] Add no_pid_tool and modify wrap pid to include labels --- Hlt/RecoConf/python/RecoConf/no_pid_tool.py | 175 ++++++++++++++++++++ scripts/wrap_pid_conditions.py | 119 ++++++++++++- 2 files changed, 292 insertions(+), 2 deletions(-) create mode 100644 Hlt/RecoConf/python/RecoConf/no_pid_tool.py diff --git a/Hlt/RecoConf/python/RecoConf/no_pid_tool.py b/Hlt/RecoConf/python/RecoConf/no_pid_tool.py new file mode 100644 index 00000000000..58e076798e4 --- /dev/null +++ b/Hlt/RecoConf/python/RecoConf/no_pid_tool.py @@ -0,0 +1,175 @@ +############################################################################### +# (c) Copyright 2025 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### +""" +Utilities to *switch off PID* in a controlled way. + +Intended use case: produce “no PID” (noPID) samples, e.g. HLT2 trigger on +simulation where PID is known to be poorly modelled and is corrected +later with data-driven tools. + +This module provides: + +- no_pid_tool: configurable that defines which PID “labels” are switched off. +- conditionally_skip: wrapper used around PID-dependent cuts. +- poison_on_demand: wrapper used around PID functors themselves, as a safety net. + +If a label is “switched off” via no_pid_tool.bind(...), then: + +- PID cuts wrapped by conditionally_skip(..., label=...) will be short-circuited. +- PID functors wrapped by poison_on_demand(..., label=...) will throw if evaluated. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import FrozenSet, Iterable, Optional + +import Functors as F +from PyConf import configurable + +# --------------------------------------------------------------------------- +# 1) Central configuration: which labels are "no PID" +# --------------------------------------------------------------------------- + + +@dataclass(frozen=True) +class _NoPidState: + """ + Internal state object returned by no_pid_tool. + + labels: + A set of labels for which PID is switched off. A “label” is just a + string attached consistently to: + - the PID functor (via poison_on_demand), + - the PID cut (via conditionally_skip). + """ + + labels: FrozenSet[str] = frozenset() + + +@configurable +def no_pid_tool( + labels: Iterable[str] = (), +) -> _NoPidState: + """ + Central knob to switch off PID for selected groups of functors / cuts. + + Typical usage in job options (for simulation): + + from RecoConf.no_pid_tool import no_pid_tool + + # Switch off PID for selected labels: + no_pid_tool.bind(labels={"PID_K", "PID_P", "PID_MU"}) + + Any PID functor / cut annotated with one of these labels will: + * be skipped via conditionally_skip(..., label="..."), + * be poisoned via poison_on_demand(..., label="..."). + + You are free to define labels however you like (per particle species, + per detector, or a single coarse label like "ALL_PID"). + """ + return _NoPidState(labels=frozenset(labels)) + + +# --------------------------------------------------------------------------- +# 2) conditionally_skip: used by the rewrite script on PID cuts +# --------------------------------------------------------------------------- + + +@configurable +def conditionally_skip( + predicate, + label: Optional[str] = None, +): + """ + Wrap a PID-dependent cut so it can be switched off. + + The libcst script will rewrite PID cuts like: + + F.PID_K > 3 + + into something like: + + conditionally_skip(F.PID_K > 3, label="PID_K") + + Behaviour: + + - If `label` is None -> no-op, just returns `predicate`. + - If `label` is not listed in no_pid_tool().labels -> no-op. + - If `label` *is* listed in no_pid_tool().labels: + return F.ACCEPT(True) | predicate + + So the functor algebra will short-circuit and `predicate` will + not be evaluated, effectively removing that PID cut. + """ + cfg = no_pid_tool() + + # If no label or label not configured for no-PID, leave the cut as-is. + if label is None or label not in cfg.labels: + return predicate + + # When this label is in "no PID" mode: force acceptance so that + # the underlying predicate is never evaluated. + # + # In C++ this corresponds to Functors::Accept{ true }. + return F.ACCEPT(True) | predicate + + +# --------------------------------------------------------------------------- +# 3) poison_on_demand: used on PID functors themselves +# --------------------------------------------------------------------------- + + +@configurable +def poison_on_demand( + functor, + label: Optional[str] = None, +): + """ + Wrap PID-related functors so they *throw* if evaluated while the + corresponding label is in "no PID" mode. + + Intended usage at functor definition time, e.g. where F.PID_K is created: + + from RecoConf.no_pid_tool import poison_on_demand + + F.PID_K = poison_on_demand(F.PID_K, label="PID_K") + F.PROBNN_K = poison_on_demand(F.PROBNN_K, label="PID_K") + + Then, when you configure a no-PID sample: + + from RecoConf.no_pid_tool import no_pid_tool + no_pid_tool.bind(labels={"PID_K"}) + + you get: + + - PID cuts rewritten as conditionally_skip(..., label="PID_K") + being skipped cleanly; and + + - any remaining use of F.PID_K / F.PROBNN_K (e.g. missed by rewriting, + or used directly elsewhere) triggering an exception, so you don't + silently get PID dependence in a “no PID” configuration. + """ + cfg = no_pid_tool() + + # If this label isn't in "no PID" mode, leave the functor unchanged. + if label is None or label not in cfg.labels: + return functor + + # When the label is in "no PID" mode: replace with a POISON functor. + # + # This matches the C++ pattern: + # Functors::Functional::Poison( Functors::PID::IsMuon, "do not use IsMuon" ); + msg = ( + f"PID functor with label {label!r} is disabled by no_pid_tool and " + f"must not be evaluated (no-PID configuration)." + ) + return F.POISON(functor, msg) diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py index 2b5c8604f6c..1034d7153c8 100755 --- a/scripts/wrap_pid_conditions.py +++ b/scripts/wrap_pid_conditions.py @@ -109,7 +109,7 @@ def contains_pid_marker(node: cst.CSTNode) -> bool: def contains_pid_or_derived(node: cst.CSTNode, derived: set[str]) -> bool: """ - True if the subtree contains a PID marker (F.PID_*, F.PROBNN_*, F.GHOSTPROB, etc.) + True if the subtree contains a PID marker (F.PID_*, F.PROBNN_*, IS_PHOTON, IS_NOT_H, ISMUON) OR references any name already marked as PID-derived. """ if contains_pid_marker(node): @@ -147,6 +147,68 @@ def is_boolean_like(node: cst.CSTNode) -> bool: return False +# NEW: map attribute name -> category label +def pid_category_from_attr_name(name: str) -> str | None: + """ + Map a PID-like attribute name to a coarse category label. + + Examples: + PID_K -> "PID" + PROBNN_MU -> "PROBNN" + IS_PHOTON -> "IS_PHOTON" + IS_NOT_H -> "IS_NOT_H" + ISMUON -> "ISMUON" + """ + upper = name.upper() + if upper.startswith("PID_"): + return "PID" + if upper.startswith("PROBNN_"): + return "PROBNN" + if upper in {"IS_PHOTON", "IS_NOT_H"}: + return upper + if upper in PID_BOOL_NAMES: + return upper + return None + + +# NEW: derive category label from an expression +def pid_label_from_expr(node: cst.CSTNode) -> str | None: + """ + Try to derive a *category* label from a PID-bearing expression. + + Strategy: + - Find the first F.PID_*/F.PROBNN_* attribute, or IS_PHOTON/IS_NOT_H/ISMUON. + - Map it to a category: + PID_* -> "PID" + PROBNN_* -> "PROBNN" + IS_PHOTON -> "IS_PHOTON" + IS_NOT_H -> "IS_NOT_H" + ISMUON -> "ISMUON" + - If none is found, return None. + """ + label: str | None = None + + class Finder(cst.CSTVisitor): + def visit_Attribute(self, n: cst.Attribute) -> None: + nonlocal label + if label is not None: + return + if is_pid_attribute(n): + cat = pid_category_from_attr_name(attr_value(n)) + if cat is not None: + label = cat + + def visit_Call(self, n: cst.Call) -> None: + # Recurse into PID wrapper calls like F.in_range(...) + if is_pid_wrapper_call(n): + for a in n.args: + if a.value is not None: + a.value.visit(self) + + node.visit(Finder()) + return label + + # ================================ # Pre-pass: collect PID-derived names # ================================ @@ -205,8 +267,27 @@ class WrapPidCuts(cst.CSTTransformer): self.derived = set(derived_names) def _wrap(self, expr: cst.BaseExpression) -> cst.Call: + """ + Wrap an expression in conditionally_skip(..., label=). + + - If we can find a PID attribute, we pass the category label + ("PID", "PROBNN", "IS_PHOTON", "IS_NOT_H", "ISMUON"). + - Otherwise we emit conditionally_skip(expr) without label + (behaves like your original implementation). + """ self.introduced_count += 1 - return cst.Call(func=cst.Name("conditionally_skip"), args=[cst.Arg(expr)]) + + label = pid_label_from_expr(expr) + + args: list[cst.Arg] = [cst.Arg(expr)] + if label is not None: + args.append( + cst.Arg( + keyword=cst.Name("label"), + value=cst.SimpleString(f'"{label}"'), + ) + ) + return cst.Call(func=cst.Name("conditionally_skip"), args=args) def visit_Call(self, node: cst.Call) -> None: self._in_cond_skip_stack.append(is_conditionally_skip_call(node)) @@ -215,6 +296,39 @@ class WrapPidCuts(cst.CSTTransformer): self, original_node: cst.Call, updated_node: cst.Call ) -> cst.BaseExpression: _ = self._in_cond_skip_stack.pop() if self._in_cond_skip_stack else False + + # 1) Upgrade existing conditionally_skip(...) calls by adding a label + # if missing. + if is_conditionally_skip_call(updated_node): + # Do nothing if there's already a label=... arg + has_label_kw = any( + isinstance(a.keyword, cst.Name) and a.keyword.value == "label" + for a in updated_node.args + if a.keyword is not None + ) + if has_label_kw: + return updated_node + + # Take the first positional argument as the predicate expression + if not updated_node.args: + return updated_node + pred_arg = updated_node.args[0].value + if pred_arg is None: + return updated_node + + label = pid_label_from_expr(pred_arg) + if label is None: + return updated_node + + new_args = list(updated_node.args) + [ + cst.Arg( + keyword=cst.Name("label"), + value=cst.SimpleString(f'"{label}"'), + ) + ] + return updated_node.with_changes(args=tuple(new_args)) + + # 2) Existing BOOL_CONSUMERS logic (unchanged) fn = func_name_like(updated_node.func) or "" if is_F_attr(updated_node.func) and (fn in BOOL_CONSUMERS): new_args = [] @@ -228,6 +342,7 @@ class WrapPidCuts(cst.CSTTransformer): v = self._wrap(v) new_args.append(a.with_changes(value=v)) return updated_node.with_changes(args=new_args) + return updated_node def leave_Comparison( -- GitLab From f1fda1ec912d44f93752c9dc38890f1a40edfd33 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Mon, 1 Dec 2025 11:31:38 +0100 Subject: [PATCH 06/16] Add no_pid_poisoning script and add two options of modified hlt2_pp_2024_no_pid --- .../hlt2_pp_2024_no_pid_functor-based copy.py | 43 +++++++++++++ .../hlt2_pp_2024_no_pid_recoconf-based.py | 60 +++++++++++++++++++ .../python/RecoConf/no_pid_poisoning.py | 23 +++++++ 3 files changed, 126 insertions(+) create mode 100644 Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py create mode 100644 Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py create mode 100644 Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py diff --git a/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py b/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py new file mode 100644 index 00000000000..8361cd7419c --- /dev/null +++ b/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py @@ -0,0 +1,43 @@ +############################################################################### +# (c) Copyright 2024 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### +from DDDB.CheckDD4Hep import UseDD4Hep +from Hlt2Conf.settings.hlt2_pp_2024 import make_streams +from Moore import options, run_moore +from RecoConf.global_tools import ( + stateProvider_with_simplified_geom, + trackMasterExtrapolator_with_simplified_geom, +) +from RecoConf.no_pid_tool import no_pid_tool +from RecoConf.reconstruction_objects import reconstruction + +options.lines_maker = make_streams + +if UseDD4Hep: + # This needs to happen before the public tools are instantiated, + # which means we cannot put it inside make_streams(). + from PyConf.Tools import TrackMasterExtrapolator, TrackMasterFitter + + TrackMasterExtrapolator.global_bind( + ApplyMultScattCorr=False, + ApplyEnergyLossCorr=False, + ApplyElectronEnergyLossCorr=False, + ) + TrackMasterFitter.global_bind(ApplyMaterialCorrections=False) + +public_tools = [ + trackMasterExtrapolator_with_simplified_geom(), + stateProvider_with_simplified_geom(), +] + +nopid_labels = {"PID", "PROBNN", "IS_PHOTON", "IS_NOT_H", "ISMUON"} + +with reconstruction.bind(from_file=False), no_pid_tool.bind(labels=nopid_labels): + config = run_moore(options, public_tools=public_tools) diff --git a/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py b/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py new file mode 100644 index 00000000000..c8580e78e3f --- /dev/null +++ b/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py @@ -0,0 +1,60 @@ +############################################################################### +# (c) Copyright 2024 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### + +from DDDB.CheckDD4Hep import UseDD4Hep +from Moore import options, run_moore +from RecoConf.global_tools import ( + stateProvider_with_simplified_geom, + trackMasterExtrapolator_with_simplified_geom, +) +from RecoConf.no_pid_poisoning import enable_pid_poisoning + +# NEW: no-PID machinery +from RecoConf.no_pid_tool import no_pid_tool +from RecoConf.reconstruction_objects import reconstruction + +# Choose which PID categories to switch off for this configuration. +# These must match the labels produced by your wrap_pid_conditions script +# and the labels used in enable_pid_poisoning(). +nopid_labels = {"PID", "PROBNN", "IS_PHOTON", "IS_NOT_H", "ISMUON"} + +# Activate the no-PID configuration *and* poison the functors +# BEFORE importing the Hlt2 lines/settings. +with no_pid_tool.bind(labels=nopid_labels): + # Poison the Functors.* PID objects under this configuration + enable_pid_poisoning() + + # Now import the Hlt2 configuration; any use of F.PID_*, F.PROBNN_*, etc. + # in cuts will see the poisoned functors and the conditionally_skip + # wrappers will also consult this bound configuration. + from Hlt2Conf.settings.hlt2_pp_2024 import make_streams + + options.lines_maker = make_streams + + if UseDD4Hep: + # This needs to happen before the public tools are instantiated, + # which means we cannot put it inside make_streams(). + from PyConf.Tools import TrackMasterExtrapolator, TrackMasterFitter + + TrackMasterExtrapolator.global_bind( + ApplyMultScattCorr=False, + ApplyEnergyLossCorr=False, + ApplyElectronEnergyLossCorr=False, + ) + TrackMasterFitter.global_bind(ApplyMaterialCorrections=False) + + public_tools = [ + trackMasterExtrapolator_with_simplified_geom(), + stateProvider_with_simplified_geom(), + ] + + with reconstruction.bind(from_file=False): + config = run_moore(options, public_tools=public_tools) diff --git a/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py b/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py new file mode 100644 index 00000000000..bfc39547e88 --- /dev/null +++ b/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py @@ -0,0 +1,23 @@ +import Functors as F + +from RecoConf.no_pid_tool import poison_on_demand + + +def enable_pid_poisoning(): + F.PID_E = poison_on_demand(F.PID_E, label="PID") + F.PID_K = poison_on_demand(F.PID_K, label="PID") + F.PID_MU = poison_on_demand(F.PID_MU, label="PID") + F.PID_P = poison_on_demand(F.PID_P, label="PID") + F.PID_PI = poison_on_demand(F.PID_PI, label="PID") + + F.PROBNN_D = poison_on_demand(F.PROBNN_D, label="PROBNN") + F.PROBNN_E = poison_on_demand(F.PROBNN_E, label="PROBNN") + F.PROBNN_GHOST = poison_on_demand(F.PROBNN_GHOST, label="PROBNN") + F.PROBNN_K = poison_on_demand(F.PROBNN_K, label="PROBNN") + F.PROBNN_MU = poison_on_demand(F.PROBNN_MU, label="PROBNN") + F.PROBNN_P = poison_on_demand(F.PROBNN_P, label="PROBNN") + F.PROBNN_PI = poison_on_demand(F.PROBNN_PI, label="PROBNN") + + F.IS_PHOTON = poison_on_demand(F.IS_PHOTON, label="IS_PHOTON") + F.IS_NOT_H = poison_on_demand(F.IS_NOT_H, label="IS_NOT_H") + F.ISMUON = poison_on_demand(F.ISMUON, label="ISMUON") -- GitLab From b446d76e0a2186e3972e4aa2267a535ea2035070 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Tue, 2 Dec 2025 09:41:17 +0100 Subject: [PATCH 07/16] Add example production.py for lbexec usage of poisoning --- Hlt/Moore/python/Moore/production.py | 80 +++++++++++++++++++++++++--- 1 file changed, 72 insertions(+), 8 deletions(-) diff --git a/Hlt/Moore/python/Moore/production.py b/Hlt/Moore/python/Moore/production.py index cb87f440ae1..c5effbdd6c9 100644 --- a/Hlt/Moore/python/Moore/production.py +++ b/Hlt/Moore/python/Moore/production.py @@ -28,6 +28,33 @@ _trkeff_probe_matching_options = { } +# --------------------------------------------------------------------------- +# Helper: turn a regex string into a set of disabled Functor labels +# --------------------------------------------------------------------------- + + +def _labels_from_regex(pattern_str, supported_labels): + """ + Given a regex string and a set of supported labels, return the subset + of labels that match the regex. Raises ConfigurationError on bad regex. + """ + if not pattern_str: + return set() + + try: + pattern = re.compile(pattern_str) + except re.error as exc: + raise ConfigurationError( + f"Invalid regex for --disable-functor-groups-regex: {pattern_str!r}" + ) from exc + + return { + label + for label in supported_labels + if pattern.fullmatch(label) or pattern.search(label) + } + + def hlt1(options: Options, *raw_args): """Setup Hlt1 with given options @@ -93,6 +120,7 @@ def hlt2(options: Options, *raw_args): args.velo_source, args.without_ut, args.trkeff_probe_matching, + args.disable_functor_groups_regex, ) @@ -156,6 +184,16 @@ def _parse_args(raw_args): help="Binds MuonProbeToLongMatcher.addNeighbouringMuonHits if not null. (default: %(default)s)", ) + # NEW: regex over Functor labels (e.g. PID, PROBNN, PID_BOOL) + parser.add_argument( + "--disable-functor-groups-regex", + default=None, + help=( + "Regular expression over Functor labels to disable. " + 'Example: "(PID|PROBNN)" disables PID and PROBNN functors/cuts.' + ), + ) + return parser.parse_args(raw_args) @@ -171,7 +209,9 @@ def _hlt2( velo_source=None, without_ut=False, trkeff_probe_matching="2025-like", + disable_functor_groups_regex=None, ): + from Functors import enable_pid_poisoning, functor_label_switches from GaudiConf.LbExec import DSTFormatTypes from PyConf.Algorithms import MuonProbeToLongMatcher from PyConf.application import metainfo_repos, retrieve_encoding_dictionary @@ -225,6 +265,12 @@ def _hlt2( ] ) + # Decide which Functor labels to disable + SUPPORTED_LABELS = {"PID", "PROBNN", "PID_BOOL"} + disabled_labels = _labels_from_regex(disable_functor_groups_regex, SUPPORTED_LABELS) + if disabled_labels: + print(f"[Moore/Hlt2] Disabling functor groups: {sorted(disabled_labels)}") + def _my_line_maker(): return _line_maker( options, @@ -237,8 +283,11 @@ def _hlt2( process="Hlt2", ) - with reconstruction.bind(from_file=False), _apply_track_binds(): - config = run_moore(options, _my_line_maker, public_tools) + # Bind labels, apply poisoning, then run Moore + with functor_label_switches.bind(labels=disabled_labels): + enable_pid_poisoning() + with reconstruction.bind(from_file=False), _apply_track_binds(): + config = run_moore(options, _my_line_maker, public_tools) if options.simulation: from Configurables import DeterministicPrescaler @@ -436,6 +485,7 @@ def spruce(options: Options, *raw_args): args.persistreco, args.rawbanks, args.reco_only, + args.disable_functor_groups_regex, ) @@ -449,8 +499,10 @@ def _spruce( persistreco=False, rawbanks=None, reco_only=False, + disable_functor_groups_regex=None, ): import Functors as F + from Functors import enable_pid_poisoning, functor_label_switches from PyConf.Algorithms import VoidFilter from PyConf.application import ( configure, @@ -476,6 +528,12 @@ def _spruce( trackMasterExtrapolator_with_simplified_geom, ) + # Decide which Functor labels to disable (same as for Hlt2) + SUPPORTED_LABELS = {"PID", "PROBNN", "PID_BOOL"} + disabled_labels = _labels_from_regex(disable_functor_groups_regex, SUPPORTED_LABELS) + if disabled_labels: + print(f"[Moore/Spruce] Disabling functor groups: {sorted(disabled_labels)}") + def _my_line_maker(): return _line_maker( options, @@ -515,7 +573,7 @@ def _spruce( options, _my_line_maker(), process="spruce" ) - ## Add this filter before `moore_control_node` using `LAZY_AND` logic IF flagging + # Add this filter before `moore_control_node` using `LAZY_AND` logic IF flagging moore_withfilter_node = CompositeNode( "MC_spruce_control_node", combine_logic=NodeLogic.LAZY_AND, @@ -525,11 +583,15 @@ def _spruce( if not flagging: moore_control_node = moore_withfilter_node - config.update( - configure(options, moore_control_node, public_tools=public_tools) - ) - ## Remove any line prescales + # Bind labels & poison before configuring + with functor_label_switches.bind(labels=disabled_labels): + enable_pid_poisoning() + config.update( + configure(options, moore_control_node, public_tools=public_tools) + ) + + # Remove any line prescales from Configurables import DeterministicPrescaler from Gaudi.Configuration import allConfigurables @@ -548,7 +610,9 @@ def _spruce( trackMasterExtrapolator_with_simplified_geom(), stateProvider_with_simplified_geom(), ] - config = run_moore(options, _my_line_maker, public_tools) + with functor_label_switches.bind(labels=disabled_labels): + enable_pid_poisoning() + config = run_moore(options, _my_line_maker, public_tools) return config -- GitLab From 03dd70a26d11942b0ad4053d4adb3798399ff7e6 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Fri, 5 Dec 2025 11:57:12 +0100 Subject: [PATCH 08/16] Adapt wrap_pid with new Rec setup --- .../hlt2_pp_2024_no_pid_functor-based copy.py | 43 ------ .../hlt2_pp_2024_no_pid_recoconf-based.py | 60 -------- scripts/wrap_pid_conditions.py | 135 ++++++++---------- 3 files changed, 58 insertions(+), 180 deletions(-) delete mode 100644 Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py delete mode 100644 Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py diff --git a/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py b/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py deleted file mode 100644 index 8361cd7419c..00000000000 --- a/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_functor-based copy.py +++ /dev/null @@ -1,43 +0,0 @@ -############################################################################### -# (c) Copyright 2024 CERN for the benefit of the LHCb Collaboration # -# # -# This software is distributed under the terms of the GNU General Public # -# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # -# # -# In applying this licence, CERN does not waive the privileges and immunities # -# granted to it by virtue of its status as an Intergovernmental Organization # -# or submit itself to any jurisdiction. # -############################################################################### -from DDDB.CheckDD4Hep import UseDD4Hep -from Hlt2Conf.settings.hlt2_pp_2024 import make_streams -from Moore import options, run_moore -from RecoConf.global_tools import ( - stateProvider_with_simplified_geom, - trackMasterExtrapolator_with_simplified_geom, -) -from RecoConf.no_pid_tool import no_pid_tool -from RecoConf.reconstruction_objects import reconstruction - -options.lines_maker = make_streams - -if UseDD4Hep: - # This needs to happen before the public tools are instantiated, - # which means we cannot put it inside make_streams(). - from PyConf.Tools import TrackMasterExtrapolator, TrackMasterFitter - - TrackMasterExtrapolator.global_bind( - ApplyMultScattCorr=False, - ApplyEnergyLossCorr=False, - ApplyElectronEnergyLossCorr=False, - ) - TrackMasterFitter.global_bind(ApplyMaterialCorrections=False) - -public_tools = [ - trackMasterExtrapolator_with_simplified_geom(), - stateProvider_with_simplified_geom(), -] - -nopid_labels = {"PID", "PROBNN", "IS_PHOTON", "IS_NOT_H", "ISMUON"} - -with reconstruction.bind(from_file=False), no_pid_tool.bind(labels=nopid_labels): - config = run_moore(options, public_tools=public_tools) diff --git a/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py b/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py deleted file mode 100644 index c8580e78e3f..00000000000 --- a/Hlt/Hlt2Conf/options/hlt2_pp_2024_no_pid_recoconf-based.py +++ /dev/null @@ -1,60 +0,0 @@ -############################################################################### -# (c) Copyright 2024 CERN for the benefit of the LHCb Collaboration # -# # -# This software is distributed under the terms of the GNU General Public # -# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # -# # -# In applying this licence, CERN does not waive the privileges and immunities # -# granted to it by virtue of its status as an Intergovernmental Organization # -# or submit itself to any jurisdiction. # -############################################################################### - -from DDDB.CheckDD4Hep import UseDD4Hep -from Moore import options, run_moore -from RecoConf.global_tools import ( - stateProvider_with_simplified_geom, - trackMasterExtrapolator_with_simplified_geom, -) -from RecoConf.no_pid_poisoning import enable_pid_poisoning - -# NEW: no-PID machinery -from RecoConf.no_pid_tool import no_pid_tool -from RecoConf.reconstruction_objects import reconstruction - -# Choose which PID categories to switch off for this configuration. -# These must match the labels produced by your wrap_pid_conditions script -# and the labels used in enable_pid_poisoning(). -nopid_labels = {"PID", "PROBNN", "IS_PHOTON", "IS_NOT_H", "ISMUON"} - -# Activate the no-PID configuration *and* poison the functors -# BEFORE importing the Hlt2 lines/settings. -with no_pid_tool.bind(labels=nopid_labels): - # Poison the Functors.* PID objects under this configuration - enable_pid_poisoning() - - # Now import the Hlt2 configuration; any use of F.PID_*, F.PROBNN_*, etc. - # in cuts will see the poisoned functors and the conditionally_skip - # wrappers will also consult this bound configuration. - from Hlt2Conf.settings.hlt2_pp_2024 import make_streams - - options.lines_maker = make_streams - - if UseDD4Hep: - # This needs to happen before the public tools are instantiated, - # which means we cannot put it inside make_streams(). - from PyConf.Tools import TrackMasterExtrapolator, TrackMasterFitter - - TrackMasterExtrapolator.global_bind( - ApplyMultScattCorr=False, - ApplyEnergyLossCorr=False, - ApplyElectronEnergyLossCorr=False, - ) - TrackMasterFitter.global_bind(ApplyMaterialCorrections=False) - - public_tools = [ - trackMasterExtrapolator_with_simplified_geom(), - stateProvider_with_simplified_geom(), - ] - - with reconstruction.bind(from_file=False): - config = run_moore(options, public_tools=public_tools) diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py index 1034d7153c8..cc5d4e16100 100755 --- a/scripts/wrap_pid_conditions.py +++ b/scripts/wrap_pid_conditions.py @@ -130,10 +130,16 @@ def contains_pid_or_derived(node: cst.CSTNode, derived: set[str]) -> bool: def is_conditionally_skip_call(node: cst.CSTNode) -> bool: + """ + Detect F.conditionally_skip(...) + """ return ( isinstance(node, cst.Call) - and isinstance(node.func, cst.Name) - and node.func.value == "conditionally_skip" + and isinstance(node.func, cst.Attribute) + and isinstance(node.func.value, cst.Name) + and node.func.value.value == "F" + and isinstance(node.func.attr, cst.Name) + and node.func.attr.value == "conditionally_skip" ) @@ -268,12 +274,11 @@ class WrapPidCuts(cst.CSTTransformer): def _wrap(self, expr: cst.BaseExpression) -> cst.Call: """ - Wrap an expression in conditionally_skip(..., label=). + Wrap an expression in F.conditionally_skip(..., label=). - If we can find a PID attribute, we pass the category label ("PID", "PROBNN", "IS_PHOTON", "IS_NOT_H", "ISMUON"). - - Otherwise we emit conditionally_skip(expr) without label - (behaves like your original implementation). + - Otherwise we emit F.conditionally_skip(expr) without label. """ self.introduced_count += 1 @@ -287,7 +292,12 @@ class WrapPidCuts(cst.CSTTransformer): value=cst.SimpleString(f'"{label}"'), ) ) - return cst.Call(func=cst.Name("conditionally_skip"), args=args) + return cst.Call( + func=cst.Attribute( + value=cst.Name("F"), attr=cst.Name("conditionally_skip") + ), + args=args, + ) def visit_Call(self, node: cst.Call) -> None: self._in_cond_skip_stack.append(is_conditionally_skip_call(node)) @@ -297,7 +307,7 @@ class WrapPidCuts(cst.CSTTransformer): ) -> cst.BaseExpression: _ = self._in_cond_skip_stack.pop() if self._in_cond_skip_stack else False - # 1) Upgrade existing conditionally_skip(...) calls by adding a label + # 1) Upgrade existing F.conditionally_skip(...) calls by adding a label # if missing. if is_conditionally_skip_call(updated_node): # Do nothing if there's already a label=... arg @@ -404,36 +414,26 @@ class WrapPidCuts(cst.CSTTransformer): # ================================ -# Transformer: ensure import +# Transformer: ensure `import Functors as F` # ================================ -class EnsureConditionallySkipImport(cst.CSTTransformer): +class EnsureFunctorsImport(cst.CSTTransformer): """ - Ensure: from RecoConf.global_tools import conditionally_skip - Only acts if `should_apply` is True. - Handles both single-line and parenthesized multi-line import-from statements. + Ensure there is an `import Functors as F` at the top of the file + if `should_apply` is True and such an import is not already present. """ def __init__(self, should_apply: bool): self.should_apply = should_apply - self.injected_or_found = False - self.added_to_existing = False + self.has_import = False self.insert_after_index = 0 - def _is_target_module(self, module: cst.CSTNode | None) -> bool: - return ( - isinstance(module, cst.Attribute) - and isinstance(module.value, cst.Name) - and module.value.value == "RecoConf" - and isinstance(module.attr, cst.Name) - and module.attr.value == "global_tools" - ) - def visit_Module(self, node: cst.Module) -> None: - idx = 0 body = node.body - # after module docstring + idx = 0 + + # Skip over module docstring if body and isinstance(body[0], cst.SimpleStatementLine): stmt = body[0] if ( @@ -442,7 +442,8 @@ class EnsureConditionallySkipImport(cst.CSTTransformer): and isinstance(stmt.body[0].value, cst.SimpleString) ): idx = 1 - # after __future__ imports + + # Skip over __future__ imports while idx < len(body): stmt = body[idx] if ( @@ -458,64 +459,43 @@ class EnsureConditionallySkipImport(cst.CSTTransformer): idx += 1 continue break - self.insert_after_index = idx - def leave_ImportFrom( - self, original_node: cst.ImportFrom, updated_node: cst.ImportFrom - ) -> cst.ImportFrom: - # If ANY import-from brings conditionally_skip into scope, mark as found - names = updated_node.names - if isinstance(names, cst.ImportStar): - if self._is_target_module(updated_node.module): - self.injected_or_found = True - return updated_node - - if isinstance(names, tuple): - for n in names: - if isinstance(n, cst.ImportAlias): - if ( - isinstance(n.name, cst.Name) - and n.name.value == "conditionally_skip" - ): - self.injected_or_found = True - - # Append to `from RecoConf.global_tools import ...` if missing - if self.should_apply and self._is_target_module(updated_node.module): - if isinstance(names, tuple): - have = any( - isinstance(n, cst.ImportAlias) - and isinstance(n.name, cst.Name) - and n.name.value == "conditionally_skip" - for n in names - ) - if not have: - new_names = list(names) + [ - cst.ImportAlias(name=cst.Name("conditionally_skip")) - ] - self.added_to_existing = True - self.injected_or_found = True - return updated_node.with_changes(names=tuple(new_names)) + self.insert_after_index = idx - return updated_node + def visit_Import(self, node: cst.Import) -> None: + # Detect existing "import Functors as F" + for alias in node.names: + if not isinstance(alias, cst.ImportAlias): + continue + if ( + isinstance(alias.name, cst.Name) + and alias.name.value == "Functors" + and alias.asname is not None + and isinstance(alias.asname.name, cst.Name) + and alias.asname.name.value == "F" + ): + self.has_import = True def leave_Module( self, original_node: cst.Module, updated_node: cst.Module ) -> cst.Module: - if not self.should_apply: + if not self.should_apply or self.has_import: return updated_node - if self.injected_or_found: - return updated_node - # Insert a fresh import line + + # Insert: import Functors as F new_import = cst.SimpleStatementLine( body=[ - cst.ImportFrom( - module=cst.Attribute( - value=cst.Name("RecoConf"), attr=cst.Name("global_tools") - ), - names=(cst.ImportAlias(name=cst.Name("conditionally_skip")),), + cst.Import( + names=[ + cst.ImportAlias( + name=cst.Name("Functors"), + asname=cst.AsName(name=cst.Name("F")), + ) + ] ) ] ) + body = list(updated_node.body) i = min(self.insert_after_index, len(body)) body.insert(i, new_import) @@ -545,10 +525,8 @@ def process_file(path: Path, write: bool) -> bool: wrapper = WrapPidCuts(derived_names=collector.derived) mod1 = mod.visit(wrapper) - # Pass 2: ensure import only if we introduced any wrappers - mod2 = mod1.visit( - EnsureConditionallySkipImport(should_apply=(wrapper.introduced_count > 0)) - ) + # Pass 2: ensure `import Functors as F` only if we introduced any wrappers + mod2 = mod1.visit(EnsureFunctorsImport(should_apply=(wrapper.introduced_count > 0))) changed = mod2.code != code if changed and write: @@ -558,7 +536,10 @@ def process_file(path: Path, write: bool) -> bool: def main(): ap = argparse.ArgumentParser( - description="Wrap PID cuts with conditionally_skip(...), including expressions using PID-derived variables, and ensure proper import." + description=( + "Wrap PID cuts with F.conditionally_skip(...), including expressions " + "using PID-derived variables, and ensure `import Functors as F`." + ) ) ap.add_argument("files", nargs="+", help=".py files to process") ap.add_argument( -- GitLab From 130dbe36b998dc6a1767be5e3a02cb57b6713847 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Sat, 6 Dec 2025 01:22:13 +0100 Subject: [PATCH 09/16] Make pid is None safe --- scripts/wrap_pid_conditions.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py index cc5d4e16100..b3c34125dbb 100755 --- a/scripts/wrap_pid_conditions.py +++ b/scripts/wrap_pid_conditions.py @@ -109,12 +109,25 @@ def contains_pid_marker(node: cst.CSTNode) -> bool: def contains_pid_or_derived(node: cst.CSTNode, derived: set[str]) -> bool: """ - True if the subtree contains a PID marker (F.PID_*, F.PROBNN_*, IS_PHOTON, IS_NOT_H, ISMUON) - OR references any name already marked as PID-derived. + True if the subtree contains a PID marker (F.PID_*, ...) OR references a + name already marked as PID-derived, *excluding* simple None-guards like + `pid is not None`. """ if contains_pid_marker(node): return True + # Special case: `derived_name is (not) None` is just a guard, not the cut. + if isinstance(node, cst.Comparison): + if isinstance(node.left, cst.Name) and node.left.value in derived: + if all( + isinstance(comp.operator, (cst.Is, cst.IsNot)) + and isinstance(comp.comparator, cst.Name) + and comp.comparator.value == "None" + for comp in node.comparisons + ): + # treat as NOT PID-related + return False + found = False class FindDerived(cst.CSTVisitor): -- GitLab From 8ea96a6a4bdcf7b8fcbc694c430835e58bfaa539 Mon Sep 17 00:00:00 2001 From: Jan wagner Date: Sat, 6 Dec 2025 01:24:38 +0100 Subject: [PATCH 10/16] Apply full poisoning mechanism on functors module --- Hlt/Hlt2Conf/options/hlt2_line_example.py | 6 +- .../options/hlt2_persistreco_fromfile.py | 4 +- .../options/hlt2_persistreco_realtime.py | 4 +- .../options/streaming/hlt2_test_streaming.py | 4 +- .../python/Hlt2Conf/flavourTagging.py | 8 +- .../b_to_charmonia/builders/basic_builder.py | 37 +- .../builders/special_builder.py | 5 +- .../b_to_charmonia/builders/x0_builder.py | 16 +- .../b_to_open_charm/bbaryon_to_cbaryon_h.py | 22 +- .../b_to_open_charm/bbaryon_to_cbaryon_hhh.py | 20 +- .../b_to_open_charm/builders/basic_builder.py | 41 +- .../Hlt2Conf/lines/bandq/builders/Bc_lines.py | 6 +- .../lines/bandq/builders/SigmacD_lines.py | 6 +- .../bandq/builders/Tetra_weak_decay_lines.py | 21 +- .../bandq/builders/b_for_spectroscopy.py | 5 +- .../lines/bandq/builders/b_to_LcX_TT_lines.py | 42 +- .../Hlt2Conf/lines/bandq/builders/b_to_cch.py | 4 +- .../bandq/builders/b_to_jpsiX_NoMuonID.py | 6 +- .../bandq/builders/b_to_jpsiX_TT_lines.py | 4 +- .../lines/bandq/builders/b_to_jpsiX_lines.py | 64 +- .../bandq/builders/bbaryon_to_lcdsX_lines.py | 9 +- .../lines/bandq/builders/bbbar_lines.py | 22 +- .../lines/bandq/builders/c_to_hadrons.py | 87 ++- .../builders/c_to_hadrons_forDoubleCharm.py | 36 +- .../lines/bandq/builders/charged_hadrons.py | 30 +- .../bandq/builders/jpsi_to_lmdlmd_lines.py | 12 +- .../lines/bandq/builders/longlived_hadrons.py | 10 +- .../lines/bandq/builders/neutral_particles.py | 16 +- .../lines/bandq/builders/ppmumu_lines.py | 12 +- .../lines/bandq/builders/qqbar_to_hadrons.py | 21 +- .../lines/bandq/builders/sexaquark_lines.py | 22 +- .../lines/bandq/builders/tcc_exclusive.py | 12 +- .../Hlt2Conf/lines/bnoc/bbaryon_to_phhh.py | 5 +- .../Hlt2Conf/lines/bnoc/bbaryon_to_pppph.py | 28 +- .../Hlt2Conf/lines/bnoc/builders/b_builder.py | 30 +- .../lines/bnoc/builders/basic_builder.py | 120 +-- .../python/Hlt2Conf/lines/charm/baryonic.py | 28 +- .../lines/charm/cbaryon_spectroscopy.py | 10 +- .../lines/charm/cbaryon_spectroscopy_mva.py | 10 +- .../lines/charm/cbaryon_to_ph0_btag.py | 33 +- .../Hlt2Conf/lines/charm/cbaryon_to_phh.py | 18 +- .../Hlt2Conf/lines/charm/cbaryon_to_pk.py | 8 +- .../Hlt2Conf/lines/charm/cbaryon_to_sl.py | 26 +- .../lines/charm/cbaryonpair_spectroscopy.py | 450 +++++------ .../Hlt2Conf/lines/charm/ccbaryon_hadronic.py | 22 +- .../lines/charm/ccbaryon_to_cbaryon_sl.py | 10 +- .../lines/charm/ccbaryon_to_hyperon_dh.py | 4 +- .../Hlt2Conf/lines/charm/charm_to_h0x.py | 10 +- .../Hlt2Conf/lines/charm/cmeson_to_sl_btag.py | 18 +- .../python/Hlt2Conf/lines/charm/d0_to_etax.py | 6 +- .../python/Hlt2Conf/lines/charm/d0_to_hh.py | 12 +- .../Hlt2Conf/lines/charm/d0_to_hhgamma.py | 14 +- .../python/Hlt2Conf/lines/charm/d0_to_hhhh.py | 8 +- .../Hlt2Conf/lines/charm/d0_to_hhpi0.py | 4 +- .../Hlt2Conf/lines/charm/d0_to_hlnux.py | 10 +- .../python/Hlt2Conf/lines/charm/d0_to_kshh.py | 14 +- .../Hlt2Conf/lines/charm/d0_to_kstmunu.py | 14 +- .../python/Hlt2Conf/lines/charm/d_to_etah.py | 20 +- .../python/Hlt2Conf/lines/charm/d_to_hhh.py | 6 +- .../Hlt2Conf/lines/charm/d_to_hhhgamma.py | 4 +- .../python/Hlt2Conf/lines/charm/d_to_ksh.py | 12 +- .../python/Hlt2Conf/lines/charm/d_to_ksksh.py | 12 +- .../lines/charm/detection_asymmetry_lines.py | 31 +- .../Hlt2Conf/lines/charm/dsstar_to_dspipi.py | 6 +- .../Hlt2Conf/lines/charm/dst_to_dee_makers.py | 32 +- .../lines/charm/hadronic_interaction_lines.py | 2 +- .../python/Hlt2Conf/lines/charm/hexaquarks.py | 48 +- .../python/Hlt2Conf/lines/charm/hyperons.py | 705 ++++++++++++------ .../python/Hlt2Conf/lines/charm/hyperonsTT.py | 20 +- .../Hlt2Conf/lines/charm/lc_to_pks_pkshh.py | 20 +- .../python/Hlt2Conf/lines/charm/prod_xsec.py | 14 +- .../Hlt2Conf/lines/charm/rare_charm_lines.py | 2 +- .../Hlt2Conf/lines/charm/rare_charm_makers.py | 28 +- .../python/Hlt2Conf/lines/charm/taggers.py | 2 +- .../Hlt2Conf/lines/charmonium_to_dimuon.py | 2 +- .../python/Hlt2Conf/lines/commissioning.py | 18 +- .../Hlt2Conf/lines/hlt2_line_example.py | 8 +- .../lines/ift/builders/smog2_CEP_builders.py | 8 +- .../lines/ift/builders/smog2_builders.py | 8 +- .../ift/builders/smog2_chargedPID_builders.py | 4 +- .../ift/builders/smog2_charm_builders.py | 2 +- .../ift/builders/smog2_muons_builders.py | 2 +- .../Hlt2Conf/lines/ift/hlt2_ift_femtoscopy.py | 8 +- .../ift/hlt2_ift_isolated_highpt_photon.py | 6 +- .../Hlt2Conf/lines/ift/hlt2_ift_pp_He.py | 2 +- .../lines/ift/hlt2_ift_pp_high_mul_charm.py | 14 +- .../lines/ift/hlt2_ift_pp_ref_2024.py | 18 +- .../lines/ift/hlt2_ift_smog2_chargedPID.py | 4 +- .../ift/spruce_ift_isolated_highpt_photon.py | 18 +- .../lines/ift/spruce_ift_pp_high_mul_charm.py | 14 +- .../lines/ift/spruce_ift_smog2_chargedPID.py | 4 +- .../lines/iftPbPb/SMOG2_Jpsi_trackeff.py | 2 +- .../dilepton_mva_builder.py | 6 +- .../Hlt2Conf/lines/monitoring/calibmon.py | 36 +- .../lines/monitoring/data_quality_PbPb.py | 2 +- .../lines/pid/BToJpsiK_JpsiToMuMuTagged.py | 2 +- .../Hlt2Conf/lines/pid/Bd2KstG_Bs2PhiG.py | 10 +- .../lines/pid/DsToPhiPi_PhiToMuMuTagged.py | 2 +- .../Hlt2Conf/lines/pid/PhiToKK_Detached.py | 2 +- .../Hlt2Conf/lines/pid/utils/charmonium.py | 8 +- .../Hlt2Conf/lines/pid/utils/filters.py | 20 +- .../Hlt2Conf/lines/pid/utils/neutral_pid.py | 38 +- .../lines/qee/b_to_majolep_majo_to_leplep.py | 6 +- .../lines/qee/dielectron_persist_photons.py | 4 +- .../python/Hlt2Conf/lines/qee/dimuon_no_ip.py | 2 +- .../python/Hlt2Conf/lines/qee/diphoton.py | 4 +- .../python/Hlt2Conf/lines/qee/drellyan.py | 2 +- .../lines/qee/drellyan_pp_ref_2024.py | 2 +- .../python/Hlt2Conf/lines/qee/qee_builders.py | 80 +- .../python/Hlt2Conf/lines/qee/quarkonia.py | 2 +- .../python/Hlt2Conf/lines/qee/sexaquark.py | 12 +- .../lines/qee/single_high_pt_electron.py | 2 +- .../python/Hlt2Conf/lines/qee/spruce_qee.py | 6 +- .../lines/qee/wz_boson_rare_decays.py | 15 +- .../python/Hlt2Conf/lines/rd/b_to_hemu.py | 66 +- .../lines/rd/b_to_hemu_control_modes.py | 26 +- .../lines/rd/b_to_multilepton_hlt2.py | 29 +- .../python/Hlt2Conf/lines/rd/b_to_xll_hlt2.py | 36 +- .../Hlt2Conf/lines/rd/b_to_xll_hlt2_mva.py | 12 +- .../Hlt2Conf/lines/rd/b_to_xll_spruce.py | 40 +- .../Hlt2Conf/lines/rd/b_to_xtaul_3pi_hlt2.py | 30 +- .../python/Hlt2Conf/lines/rd/baryonic.py | 2 +- .../python/Hlt2Conf/lines/rd/baryonic_mva.py | 11 +- .../Hlt2Conf/lines/rd/bnv_lines_hlt2.py | 14 +- .../lines/rd/btosmutau_exclusive_spruce.py | 47 +- .../lines/rd/btostautau_ee_exclusive_hlt2.py | 50 +- .../lines/rd/btostautau_exclusive_hlt2.py | 44 +- .../lines/rd/btostautau_exclusive_spruce.py | 51 +- .../lines/rd/btostautau_mue_exclusive_hlt2.py | 54 +- .../rd/btostautau_mupi_exclusive_hlt2.py | 54 +- .../lines/rd/btostautau_pie_exclusive_hlt2.py | 60 +- .../rd/btostautau_pipi_exclusive_hlt2.py | 50 +- .../lines/rd/builders/RpK_builders.py | 9 +- .../b_to_Xdilepton_detached_builders.py | 8 +- .../lines/rd/builders/b_to_ll_LFV_builder.py | 6 +- .../b_to_xgamma_exclusive_builders.py | 57 +- .../lines/rd/builders/b_to_xll_builders.py | 6 +- .../rd/builders/b_to_xtaul_3pi_builder.py | 27 +- .../lines/rd/builders/baryonic_builders.py | 13 +- .../builders/baryonic_radiative_builders.py | 50 +- .../builders/prompt_multilepton_builders.py | 28 +- .../lines/rd/builders/qqbar_to_ll_builders.py | 20 +- .../rd/builders/rare_tau_decay_builders.py | 8 +- .../Hlt2Conf/lines/rd/builders/strange.py | 39 +- .../Hlt2Conf/lines/rd/prompt_multilepton.py | 4 +- .../python/Hlt2Conf/lines/rd/qqbar_to_ll.py | 28 +- .../Hlt2Conf/lines/rd/rare_tau_decay_lines.py | 28 +- .../lines/semileptonic/HbToHbprimeLNu.py | 18 +- .../Hlt2Conf/lines/semileptonic/HbToHcLNu.py | 42 +- .../semileptonic/HbToHcTauNu_TauToLNuNu.py | 66 +- .../semileptonic/HbToHcTauNu_TauToPiPiPiNu.py | 52 +- .../Hlt2Conf/lines/semileptonic/HbToHuLNu.py | 58 +- .../semileptonic/HbToHuTauNu_TauToPiPiPiNu.py | 12 +- .../Hlt2Conf/lines/semileptonic/HbToLLLNu.py | 39 +- .../Hlt2Conf/lines/semileptonic/HbToLNu.py | 16 +- .../lines/semileptonic/HbToTauNu_BTracking.py | 4 +- .../semileptonic/builders/base_builder.py | 82 +- .../builders/charm_hadron_builder.py | 77 +- .../semileptonic/builders/dilepton_builder.py | 2 +- .../python/Hlt2Conf/lines/test/hlt2_test.py | 75 +- .../python/Hlt2Conf/lines/test/spruce_test.py | 14 +- .../lines/trackeff/DiMuonTrackEfficiency.py | 2 +- .../lines/trackeff/JpsiToMuMu_PVTracks.py | 182 ++--- .../Hlt2Conf/lines/trackeff/KSVeloLong.py | 2 +- .../lines/trackeff/SMOG2_Jpsi_trackeff.py | 2 +- .../Velo2Long_B2JpsiK_ElectronProbe.py | 4 +- .../trackeff/Velo2Long_B2JpsiK_MuonProbe.py | 4 +- .../trackeff/Velo2Long_Ds2PhiPi_KaonProbe.py | 8 +- .../trackeff/Velo2Long_L2PPi_ProtonProbe.py | 2 +- .../lines/trackeff/ZUpsilonFullEvent.py | 2 +- .../triggereff/triggereff_beauty_hlt2.py | 11 +- .../lines/triggereff/triggereff_charm_hlt2.py | 4 +- .../python/Hlt2Conf/settings/hlt2_slim.py | 4 +- .../spruce_bandwidth_PbPb_lumi_streams.py | 1 + .../options/hlt2_combinations_particle_v2.py | 4 +- .../tests/options/test_bremsstrahlung.py | 5 +- .../options/hlt2_particles_baseline.py | 10 +- .../python/RecoConf/monitoring_particles.py | 55 +- .../python/RecoConf/no_pid_poisoning.py | 34 +- .../python/RecoConf/rdbuilder_thor.py | 85 ++- .../python/RecoConf/standard_particles.py | 50 +- ReleaseNotes/legacy.html | 10 + 182 files changed, 3153 insertions(+), 1787 deletions(-) diff --git a/Hlt/Hlt2Conf/options/hlt2_line_example.py b/Hlt/Hlt2Conf/options/hlt2_line_example.py index 2a379e55a6f..11d29181811 100644 --- a/Hlt/Hlt2Conf/options/hlt2_line_example.py +++ b/Hlt/Hlt2Conf/options/hlt2_line_example.py @@ -45,7 +45,7 @@ def filter_protons(particles, pvs, pt_min=0.5 * GeV, mipchi2_min=9, dllp_min=5): cut = require_all( F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_P > dllp_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) @@ -54,7 +54,7 @@ def filter_kaons(particles, pvs, pt_min=0.5 * GeV, mipchi2_min=9, dllk_min=5): cut = require_all( F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) @@ -63,7 +63,7 @@ def filter_pions(particles, pvs, pt_min=0.5 * GeV, mipchi2_min=9, dllk_max=5): cut = require_all( F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/options/hlt2_persistreco_fromfile.py b/Hlt/Hlt2Conf/options/hlt2_persistreco_fromfile.py index c3d2dc15f60..433739c3ee0 100644 --- a/Hlt/Hlt2Conf/options/hlt2_persistreco_fromfile.py +++ b/Hlt/Hlt2Conf/options/hlt2_persistreco_fromfile.py @@ -82,7 +82,7 @@ def make_dzeros(particle1, particle2, name, descriptor): def test_persistreco_line(name="Hlt2_test_persistreco", prescale=1, persistreco=True): - kaons = make_charm_kaons(pidk_cut=F.PID_K < 15) + kaons = make_charm_kaons(pidk_cut=F.conditionally_skip(F.PID_K < 15, label="PID")) dzeros = make_dzeros( particle1=kaons, particle2=kaons, @@ -100,7 +100,7 @@ def test_persistreco_line(name="Hlt2_test_persistreco", prescale=1, persistreco= def test_nopersistreco_line( name="Hlt2_test_nopersistreco", prescale=1, persistreco=False ): - kaons = make_charm_kaons(pidk_cut=F.PID_K > 15) + kaons = make_charm_kaons(pidk_cut=F.conditionally_skip(F.PID_K > 15, label="PID")) dzeros = make_dzeros( particle1=kaons, particle2=kaons, diff --git a/Hlt/Hlt2Conf/options/hlt2_persistreco_realtime.py b/Hlt/Hlt2Conf/options/hlt2_persistreco_realtime.py index af2c36579c2..da7fcffad09 100644 --- a/Hlt/Hlt2Conf/options/hlt2_persistreco_realtime.py +++ b/Hlt/Hlt2Conf/options/hlt2_persistreco_realtime.py @@ -82,7 +82,7 @@ def make_dzeros(particle1, particle2, name, descriptor): def test_persistreco_line(name="Hlt2_test_persistreco", prescale=1, persistreco=True): - kaons = make_charm_kaons(pidk_cut=F.PID_K > 5) + kaons = make_charm_kaons(pidk_cut=F.conditionally_skip(F.PID_K > 5, label="PID")) dzeros = make_dzeros( particle1=kaons, particle2=kaons, @@ -100,7 +100,7 @@ def test_persistreco_line(name="Hlt2_test_persistreco", prescale=1, persistreco= def test_nopersistreco_line( name="Hlt2_test_nopersistreco", prescale=1, persistreco=False ): - kaons = make_charm_kaons(pidk_cut=F.PID_K < 5) + kaons = make_charm_kaons(pidk_cut=F.conditionally_skip(F.PID_K < 5, label="PID")) dzeros = make_dzeros( particle1=kaons, particle2=kaons, diff --git a/Hlt/Hlt2Conf/options/streaming/hlt2_test_streaming.py b/Hlt/Hlt2Conf/options/streaming/hlt2_test_streaming.py index 74297bccd4d..81af6d0cdf9 100644 --- a/Hlt/Hlt2Conf/options/streaming/hlt2_test_streaming.py +++ b/Hlt/Hlt2Conf/options/streaming/hlt2_test_streaming.py @@ -101,7 +101,7 @@ def make_dzeros(particle1, particle2, name, descriptor): def test_A_line(name="Hlt2_test_stream_A_line", prescale=1): - kaons = make_charm_kaons(pidk_cut=F.PID_K > 15) + kaons = make_charm_kaons(pidk_cut=F.conditionally_skip(F.PID_K > 15, label="PID")) dzeros = make_dzeros( particle1=kaons, particle2=kaons, @@ -118,7 +118,7 @@ def test_A_line(name="Hlt2_test_stream_A_line", prescale=1): def test_B_line(name="Hlt2_test_stream_B_line", prescale=1): # intentionally have some overlap with the other line in order to test # the routing bits in events going to both streams. - kaons = make_charm_kaons(pidk_cut=F.PID_K > 0) + kaons = make_charm_kaons(pidk_cut=F.conditionally_skip(F.PID_K > 0, label="PID")) dzeros = make_dzeros( particle1=kaons, particle2=kaons, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/flavourTagging.py b/Hlt/Hlt2Conf/python/Hlt2Conf/flavourTagging.py index b3483c300b9..433867b28cd 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/flavourTagging.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/flavourTagging.py @@ -82,8 +82,8 @@ def make_run2_sameside_tagging_pions( F.P < p_max, F.PT > pt_min, F.PT < pt_max, - F.PID_P < pidp_max, - F.PID_K < pidk_max, + F.conditionally_skip(F.PID_P < pidp_max, label="PID"), + F.conditionally_skip(F.PID_K < pidk_max, label="PID"), F.GHOSTPROB < ghostprob_max, F.ETA < eta_max, ) @@ -135,7 +135,7 @@ def make_run2_sameside_tagging_protons( F.P < p_max, F.PT > pt_min, F.PT < pt_max, - F.PID_P > pidp_min, + F.conditionally_skip(F.PID_P > pidp_min, label="PID"), F.GHOSTPROB < ghostprob_max, F.ETA < eta_max, ) @@ -193,7 +193,7 @@ def make_run2_oppositeside_tagging_electrons( F.GHOSTPROB < ghostprob_max, F.ETA < eta_max, F.CHI2DOF < trchi2dof_max, - F.PID_E > PIDe_min, + F.conditionally_skip(F.PID_E > PIDe_min, label="PID"), ) selected_tagging_particle_containers = [] for tagging_particle_container in tagging_particle_containers: diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/basic_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/basic_builder.py index 985cfddc6a4..ffa86a24bd6 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/basic_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/basic_builder.py @@ -99,7 +99,7 @@ def make_pions(pid=5, pt=200 * MeV, p=1 * GeV, mipchi2_min=0, **decay_arguments) """Return pions filtered by thresholds common to B2CC decay product selections.""" if pid is not None: - pid = F.PID_K < pid + pid = F.conditionally_skip(F.PID_K < pid, label="PID") return make_selected_particles( make_particles=make_has_rich_long_pions, @@ -125,8 +125,8 @@ def make_PionsforB2JpsiK( ): """Return pions filtered by thresholds common to BnoC decay product selections.""" if pid is not None: - pid = F.PID_K < pid - pid &= F.ISMUON == 0 + pid = F.conditionally_skip(F.PID_K < pid, label="PID") + pid &= F.conditionally_skip(F.ISMUON == 0, label="ISMUON") return make_selected_particles( make_particles=make_has_rich_long_pions, pt_min=pt_min, @@ -149,7 +149,7 @@ def make_kaons(pid=-3, pt=200 * MeV, p=2 * GeV, **decay_arguments): make_particles=make_has_rich_long_kaons, pt_min=pt, p_min=p, - pid=(F.PID_K > pid), + pid=F.conditionally_skip((F.PID_K > pid), label="PID"), **decay_arguments, ) @@ -170,8 +170,8 @@ def make_BachelorKaonsforB2JpsiK( ): """Return pions filtered by thresholds common to BnoC decay product selections.""" if pid is not None: - pid = F.PID_K > pid - pid &= F.ISMUON == 0 + pid = F.conditionally_skip(F.PID_K > pid, label="PID") + pid &= F.conditionally_skip(F.ISMUON == 0, label="ISMUON") return make_selected_particles( make_particles=make_has_rich_long_kaons, pt_min=pt_min, @@ -196,8 +196,8 @@ def make_photons_to_preserve(tracks): F.require_all( F.PT > 100 * MeV, F.P > 0 * MeV, - F.IS_PHOTON > 0.0, - F.IS_NOT_H > 0.2, + F.conditionally_skip(F.IS_PHOTON > 0.0, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.2, label="IS_NOT_H"), F.CALO_NEUTRAL_SHOWER_SHAPE > 0, ), ), @@ -226,7 +226,7 @@ def make_muons( """Return muons filtered by thresholds common to B2CC decay product selections.""" if pid is not None: - pid = F.PID_MU > pid + pid = F.conditionally_skip(F.PID_MU > pid, label="PID") return make_selected_particles( make_particles=make_ismuon_long_muon, @@ -256,7 +256,7 @@ def make_electrons( pt_min=0.0, pt_with_brem_min=pt_with_brem, mipchi2_min=mipchi2_min, - pid=(F.PID_E > pid), + pid=F.conditionally_skip((F.PID_E > pid), label="PID"), max_trghostprob=max_trghostprob, **decay_arguments, ) @@ -271,7 +271,10 @@ def make_protons( make_particles=make_has_rich_long_protons, p_min=p_min, mipchi2_min=mipchi2_min, - pid=((F.PID_P > pid_p) & ((F.PID_P - F.PID_K) > delta_pid_pK)), + pid=( + F.conditionally_skip((F.PID_P > pid_p), label="PID") + & F.conditionally_skip(((F.PID_P - F.PID_K) > delta_pid_pK), label="PID") + ), **decay_arguments, ) @@ -291,9 +294,9 @@ def make_ProtonsforB2JpsiK( ): """Return protons filtered by thresholds common to BnoC decay product selections.""" if pid is not None: - pid = F.PID_P > pid - pid &= F.ISMUON == 0 - pid &= F.PID_P - F.PID_K > p_pid_pkdiff + pid = F.conditionally_skip(F.PID_P > pid, label="PID") + pid &= F.conditionally_skip(F.ISMUON == 0, label="ISMUON") + pid &= F.conditionally_skip(F.PID_P - F.PID_K > p_pid_pkdiff, label="PID") return make_selected_particles( make_particles=make_has_rich_long_protons, pt_min=pt_min, @@ -668,12 +671,12 @@ def filter_muons_loose( ): """Returns loosely preselected muons""" code = require_all( - F.ISMUON, F.PID_MU > pidmu, F.PT > pt_min + F.ISMUON, F.conditionally_skip(F.PID_MU > pidmu, label="PID"), F.PT > pt_min ) # , F.MAXSDOCACUT(docachi2_max_mu)) if mu_pidk is not None: - code = code & (F.PID_K < mu_pidk) + code = code & F.conditionally_skip((F.PID_K < mu_pidk), label="PID") if mu_pidp is not None: - code = code & (F.PID_P < mu_pidp) + code = code & F.conditionally_skip((F.PID_P < mu_pidp), label="PID") return ParticleFilter(particles, F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/special_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/special_builder.py index 5882d2350b2..166616a0e58 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/special_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/special_builder.py @@ -87,11 +87,12 @@ def make_JpsiPP_X( F.SUM(F.P) > pp_min_sump, F.require_any(F.CHILD(1, F.P) > p_min_p, F.CHILD(2, F.P) > p_min_p), F.require_any(F.CHILD(1, F.PT) > p_min_pt, F.CHILD(2, F.PT) > p_min_pt), - prod_probnn_p > min_prodprobnn_pp, + F.conditionally_skip(prod_probnn_p > min_prodprobnn_pp), ) combination123_code = F.require_all( # ppbarK+ combination - F.MAXSDOCACHI2CUT(sdocachi2_max), prod_probnn_p_k > min_prodprobnn_p_k + F.MAXSDOCACHI2CUT(sdocachi2_max), + F.conditionally_skip(prod_probnn_p_k > min_prodprobnn_p_k), ) if X_kstar is True: diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/x0_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/x0_builder.py index 93012c28bb4..e3990c09f6e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/x0_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_charmonia/builders/x0_builder.py @@ -31,7 +31,10 @@ _pi0_M = 134.977 * MeV def filter_gammas(particles, gpt_min=250.0 * MeV, gpt_max=200.0 * GeV, isnoth_min=0.2): - code = require_all(in_range(gpt_min, F.PT, gpt_max), F.IS_NOT_H > isnoth_min) + code = require_all( + in_range(gpt_min, F.PT, gpt_max), + F.conditionally_skip(F.IS_NOT_H > isnoth_min, label="IS_NOT_H"), + ) return ParticleFilter(particles, F.FILTER(code)) @@ -75,7 +78,11 @@ def make_resolved_etas( def electrons_for_convertedgamma(electrons, name="b2cc_make_e_for_gee_{hash}"): # make and filter electrons to build converted photons # suitable for both long and down tracks - filter_code = F.require_all(F.PT > 90.0 * MeV, F.P > 0.9 * GeV, F.PID_E > -2.0) + filter_code = F.require_all( + F.PT > 90.0 * MeV, + F.P > 0.9 * GeV, + F.conditionally_skip(F.PID_E > -2.0, label="PID"), + ) return ParticleFilter( electrons(), F.FILTER(filter_code), @@ -116,7 +123,10 @@ def make_gamma_ee_LL( gamma = loose_gamma_ee( electrons, m_diE_max=45.0 * MeV, pt_diE_min=pt_diE_min, name=name ) - code_tight = F.require_any(F.CHILD(1, F.PID_E) > 2.0, F.CHILD(2, F.PID_E) > 2.0) + code_tight = F.require_any( + F.conditionally_skip(F.CHILD(1, F.PID_E) > 2.0, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_E) > 2.0, label="PID"), + ) return ParticleFilter(gamma, F.FILTER(code_tight), name=name) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_h.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_h.py index b4b64f53756..c81719a0527 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_h.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_h.py @@ -257,9 +257,9 @@ def make_Xib0ToXicpPi_XicpToPKPi(process): cbaryon_init = cbaryon_builder.make_xicp_to_pkpi() cbaryon_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -289,10 +289,10 @@ def make_XibmToXic0Pi_Xic0ToPKKPi(process): cbaryon_init = cbaryon_builder.make_xic0_to_pkkpi() cbaryon_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_K) > 0.1, - F.CHILD(4, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(4, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -335,10 +335,10 @@ def make_OmbmToOmc0Pi_Omc0ToPKKPi(process): cbaryon_init = cbaryon_builder.make_omegac0_to_pkkpi() cbaryon_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_K) > 0.1, - F.CHILD(4, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(4, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_hhh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_hhh.py index 6c6adb9beaa..8c258470725 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_hhh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/bbaryon_to_cbaryon_hhh.py @@ -33,9 +33,9 @@ def make_LbToLcpPiPiPi_LcpToPKPi(process): cbaryon_init = cbaryon_builder.make_lc_to_pkpi() cbaryon_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -190,9 +190,9 @@ def make_Xib0ToXicpPiPiPi_XicpToPKPi(process): cbaryon_init = cbaryon_builder.make_xicp_to_pkpi() cbaryon_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -360,10 +360,10 @@ def make_OmbmToOmc0PiPiPi_Omc0ToPKKPi(process): cbaryon_init = cbaryon_builder.make_omegac0_to_pkkpi() cbaryon_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_K) > 0.1, - F.CHILD(4, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(4, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/builders/basic_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/builders/basic_builder.py index 957dc212785..26066d1c779 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/builders/basic_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/b_to_open_charm/builders/basic_builder.py @@ -60,7 +60,7 @@ def make_pions(pi_pidk_max=5.0, p_min=2 * GeV, pt_min=250 * MeV, **decay_argumen **decay_arguments, ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -75,7 +75,7 @@ def make_kaons(k_pidk_min=-5.0, p_min=2 * GeV, pt_min=250 * MeV, **decay_argumen **decay_arguments, ) if k_pidk_min is not None: - code = F.PID_K > k_pidk_min + code = F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -92,9 +92,11 @@ def make_protons( **decay_arguments, ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") if p_pidkmp_max is not None: - code &= (F.PID_K - F.PID_P) < p_pidkmp_max + code &= F.conditionally_skip( + (F.PID_K - F.PID_P) < p_pidkmp_max, label="PID" + ) protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -108,7 +110,7 @@ def make_tight_pions( make_particles=make_has_rich_long_pions, p_min=p_min, pt_min=pt_min ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -126,7 +128,7 @@ def make_soft_pions(pi_pidk_max=20, p_min=2 * GeV, pt_min=100 * MeV): make_particles=make_has_rich_long_pions, p_min=p_min, pt_min=pt_min ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -149,7 +151,7 @@ def make_tight_kaons( **decay_arguments, ) if k_pidk_min is not None: - code = F.PID_K > k_pidk_min + code = F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -167,7 +169,7 @@ def make_soft_kaons(k_pidk_min=-10, p_min=2 * GeV, pt_min=100 * MeV): make_particles=make_has_rich_long_kaons, p_min=p_min, pt_min=pt_min ) if k_pidk_min is not None: - code = F.PID_K > k_pidk_min + code = F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -194,9 +196,11 @@ def make_tight_protons( **decay_arguments, ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") if p_pidkmp_max is not None: - code &= (F.PID_K - F.PID_P) < p_pidkmp_max + code &= F.conditionally_skip( + (F.PID_K - F.PID_P) < p_pidkmp_max, label="PID" + ) protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -216,9 +220,11 @@ def make_soft_protons( make_particles=make_has_rich_long_protons, p_min=p_min, pt_min=pt_min ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") if p_pidkmp_max is not None: - code &= (F.PID_K - F.PID_P) < p_pidkmp_max + code &= F.conditionally_skip( + (F.PID_K - F.PID_P) < p_pidkmp_max, label="PID" + ) protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -240,7 +246,7 @@ def make_muons( make_particles = make_inmuon_long_muon muons = filter_particles(make_particles=make_particles, p_min=p_min, pt_min=pt_min) if mu_pidmu_min is not None: - code = F.PID_MU > mu_pidmu_min + code = F.conditionally_skip(F.PID_MU > mu_pidmu_min, label="PID") muons = ParticleFilter(muons, F.FILTER(code)) return muons @@ -252,7 +258,9 @@ def make_muons( @configurable def make_photons(make_particles=make_photons, CL_min=0.25, et_min=150 * MeV): - code = require_all(F.IS_NOT_H > CL_min, F.PT > et_min) + code = require_all( + F.conditionally_skip(F.IS_NOT_H > CL_min, label="IS_NOT_H"), F.PT > et_min + ) return ParticleFilter(make_particles(), F.FILTER(code)) @@ -272,7 +280,8 @@ def make_resolved_pi0s( code &= F.P > p_min if CL_min is not None: code &= require_all( - F.CHILD(1, F.IS_NOT_H) > CL_min, F.CHILD(2, F.IS_NOT_H) > CL_min + F.conditionally_skip(F.CHILD(1, F.IS_NOT_H) > CL_min, label="IS_NOT_H"), + F.conditionally_skip(F.CHILD(2, F.IS_NOT_H) > CL_min, label="IS_NOT_H"), ) return ParticleFilter(make_particles(), F.FILTER(code)) @@ -285,7 +294,7 @@ def make_merged_pi0s( if p_min is not None: code &= F.P > p_min if CL_min is not None: - code &= F.IS_PHOTON < 1.0 - CL_min + code &= F.conditionally_skip(F.IS_PHOTON < 1.0 - CL_min, label="IS_PHOTON") return ParticleFilter(make_particles(), F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Bc_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Bc_lines.py index 54a143469a9..db4cb5464ee 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Bc_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Bc_lines.py @@ -33,7 +33,7 @@ def make_proton_forBc3h( name="bandq_proton_forBc3h_{hash}", pt_min=800.0 * MeV, p_min=10.0 * GeV, - pid=(F.PID_P > 5.0), + pid=F.conditionally_skip((F.PID_P > 5.0), label="PID"), mipchi2dvprimary_min=9.0, ): return charged_hadrons.make_detached_protons( @@ -50,7 +50,7 @@ def make_pion_forBc3h( name="bandq_pion_forBc3h_{hash}", pt_min=1000.0 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K < -5.0), + pid=F.conditionally_skip((F.PID_K < -5.0), label="PID"), mipchi2dvprimary_min=12.0, ): return charged_hadrons.make_detached_pions( @@ -67,7 +67,7 @@ def make_kaon_forBc3h( name="bandq_kaon_forBc3h_{hash}", pt_min=1000.0 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), mipchi2dvprimary_min=12.0, ): return charged_hadrons.make_detached_kaons( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/SigmacD_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/SigmacD_lines.py index cba494e142a..b67272261b2 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/SigmacD_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/SigmacD_lines.py @@ -49,7 +49,7 @@ def _make_protons( F.PT > pt_min, F.P > p_min, F.CHI2DOF < 99.0, - F.PROBNN_P > probnnp_min, + F.conditionally_skip(F.PROBNN_P > probnnp_min, label="PROBNN"), ), ), ) @@ -70,7 +70,7 @@ def _make_kaons( F.PT > pt_min, F.P > p_min, F.CHI2DOF < 99.0, - F.PROBNN_K > probnnk_min, + F.conditionally_skip(F.PROBNN_K > probnnk_min, label="PROBNN"), ), ), ) @@ -86,7 +86,7 @@ def _make_pions(pt_min=200 * MeV, p_min=2.0 * GeV, mipchi2_min=4.0, probnnpi_min F.PT > pt_min, F.P > p_min, F.CHI2DOF < 99.0, - F.PROBNN_PI > probnnpi_min, + F.conditionally_skip(F.PROBNN_PI > probnnpi_min, label="PROBNN"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Tetra_weak_decay_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Tetra_weak_decay_lines.py index e2015ab5b0e..3cd0480b865 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Tetra_weak_decay_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/Tetra_weak_decay_lines.py @@ -207,12 +207,22 @@ def make_ZccToDspKmPip(name="bandq_ZccToDspKmPip_{hash}"): kaon = charged_hadrons.make_detached_kaons( mipchi2dvprimary_min=12.0, pt_min=500.0 * MeV, - pid=(F.require_all(F.PID_K > 0.0, F.PROBNN_K > 0.4)), + pid=( + F.require_all( + F.conditionally_skip(F.PID_K > 0.0, label="PID"), + F.conditionally_skip(F.PROBNN_K > 0.4, label="PROBNN"), + ) + ), ) pion = charged_hadrons.make_detached_pions( mipchi2dvprimary_min=12.0, pt_min=500.0 * MeV, - pid=(F.require_all(F.PID_K < 0.0, F.PROBNN_PI > 0.4)), + pid=( + F.require_all( + F.conditionally_skip(F.PID_K < 0.0, label="PID"), + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + ) + ), ) Dsp = make_DspToKmKpPip_tightip() myzcc = b_hadrons.make_bu_tight( @@ -239,7 +249,12 @@ def make_ZccToDspKSPip(name="bandq_ZccToDspKSPip_{hash}"): pion = charged_hadrons.make_detached_pions( mipchi2dvprimary_min=12.0, pt_min=500.0 * MeV, - pid=(F.require_all(F.PID_K < 0.0, F.PROBNN_PI > 0.4)), + pid=( + F.require_all( + F.conditionally_skip(F.PID_K < 0.0, label="PID"), + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + ) + ), ) Dsp = make_DspToKmKpPip_tightip() myzcc = b_hadrons.make_bu_tight( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_for_spectroscopy.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_for_spectroscopy.py index 28616d9a7ba..a3528601d9d 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_for_spectroscopy.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_for_spectroscopy.py @@ -424,7 +424,10 @@ def make_protons_from_b(): pt_min=150.0 * MeV, p_min=1.0 * GeV, mipchi2dvprimary_min=4, - pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 0.0, label="PID"), + ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_LcX_TT_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_LcX_TT_lines.py index 3937c4db3b0..0cb1be99a0f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_LcX_TT_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_LcX_TT_lines.py @@ -42,12 +42,12 @@ def make_EMDM_LambdaTT_CutTTPID( Cut the PIDe variable to remove gamma conversion BKGs. Use it to reduce the bandwidth tension of high-rate lines. """ code = F.require_all( - F.CHILD(1, F.PID_E) < PIDe_max, - F.CHILD(1, F.PID_P) > p_PIDp_min, + F.conditionally_skip(F.CHILD(1, F.PID_E) < PIDe_max, label="PID"), + F.conditionally_skip(F.CHILD(1, F.PID_P) > p_PIDp_min, label="PID"), F.CHILD(1, F.GHOSTPROB) < ghostprob_max, F.CHILD(1, F.OWNPVIPCHI2) > ownpvipchi2_min, - F.CHILD(2, F.PID_E) < PIDe_max, - F.CHILD(2, F.PID_K) < pi_PIDK_max, + F.conditionally_skip(F.CHILD(2, F.PID_E) < PIDe_max, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_K) < pi_PIDK_max, label="PID"), F.CHILD(2, F.GHOSTPROB) < ghostprob_max, F.CHILD(2, F.OWNPVIPCHI2) > ownpvipchi2_min, ) @@ -68,14 +68,14 @@ def make_EMDM_KsTT_CutTTPID( Cut the PIDe variable to remove gamma conversion BKGs. Use it to reduce the bandwidth tension of high-rate lines. """ code = F.require_all( - F.CHILD(1, F.PID_E) < PIDe_max, - F.CHILD(1, F.PID_K) < pi_PIDK_max, - F.CHILD(1, F.PID_P) < pi_PIDP_max, + F.conditionally_skip(F.CHILD(1, F.PID_E) < PIDe_max, label="PID"), + F.conditionally_skip(F.CHILD(1, F.PID_K) < pi_PIDK_max, label="PID"), + F.conditionally_skip(F.CHILD(1, F.PID_P) < pi_PIDP_max, label="PID"), F.CHILD(1, F.GHOSTPROB) < ghostprob_max, F.CHILD(1, F.OWNPVIPCHI2) > ownpvipchi2_min, - F.CHILD(2, F.PID_E) < PIDe_max, - F.CHILD(2, F.PID_K) < pi_PIDK_max, - F.CHILD(2, F.PID_P) < pi_PIDP_max, + F.conditionally_skip(F.CHILD(2, F.PID_E) < PIDe_max, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_K) < pi_PIDK_max, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_P) < pi_PIDP_max, label="PID"), F.CHILD(2, F.GHOSTPROB) < ghostprob_max, F.CHILD(2, F.OWNPVIPCHI2) > ownpvipchi2_min, ) @@ -105,9 +105,9 @@ def make_EMDM_detached_Pion_base( F.P > p_min, F.PT > pt_min, F.OWNPVIPCHI2 > mipchi2_min, - F.PID_K < pidk_max, + F.conditionally_skip(F.PID_K < pidk_max, label="PID"), F.GHOSTPROB < ghostprob_max, - F.PROBNN_PI > probnnpi_min, + F.conditionally_skip(F.PROBNN_PI > probnnpi_min, label="PROBNN"), ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) @@ -125,7 +125,10 @@ def make_EMDM_detached_Muon_base( The baseline for long-track muons used in EMDM measurements in Lb->LcX, Lc->LX decays """ code = F.require_all( - F.P > p_min, F.PT > pt_min, F.OWNPVIPCHI2 > mipchi2_min, F.PID_MU > pidmu_min + F.P > p_min, + F.PT > pt_min, + F.OWNPVIPCHI2 > mipchi2_min, + F.conditionally_skip(F.PID_MU > pidmu_min, label="PID"), ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) @@ -147,8 +150,8 @@ def make_EMDM_detached_bachPion_fromCharm( F.P > p_min, F.PT > pt_min, F.OWNPVIPCHI2 > mipchi2_min, - F.PID_K < pidk_max, - F.PROBNN_PI > probnnpi_min, + F.conditionally_skip(F.PID_K < pidk_max, label="PID"), + F.conditionally_skip(F.PROBNN_PI > probnnpi_min, label="PROBNN"), ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) @@ -170,8 +173,8 @@ def make_EMDM_detached_bachPion_fromBeauty( F.P > p_min, F.PT > pt_min, F.OWNPVIPCHI2 > mipchi2_min, - F.PID_K < pidk_max, - F.PROBNN_PI > probnnpi_min, + F.conditionally_skip(F.PID_K < pidk_max, label="PID"), + F.conditionally_skip(F.PROBNN_PI > probnnpi_min, label="PROBNN"), ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) @@ -189,7 +192,10 @@ def make_EMDM_detached_bachMuon( Builder for a long-track detached Muon to build b Semileptonic decays, not vertexing with any other particles. """ code = F.require_all( - F.P > p_min, F.PT > pt_min, F.OWNPVIPCHI2 > mipchi2_min, F.PID_MU > pidmu_min + F.P > p_min, + F.PT > pt_min, + F.OWNPVIPCHI2 > mipchi2_min, + F.conditionally_skip(F.PID_MU > pidmu_min, label="PID"), ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_cch.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_cch.py index 793c8cfd0ad..9b184e78526 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_cch.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_cch.py @@ -135,7 +135,7 @@ def make_pions_from_B(): return charged_hadrons.make_detached_pions( pt_min=250 * MeV, p_min=2 * GeV, - pid=F.PROBNN_PI > 0.1, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) @@ -143,7 +143,7 @@ def make_kaons_from_B(): return charged_hadrons.make_detached_kaons( pt_min=250 * MeV, p_min=2 * GeV, - pid=F.PROBNN_K > 0.1, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_NoMuonID.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_NoMuonID.py index dffca82e323..fc7ac92f729 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_NoMuonID.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_NoMuonID.py @@ -205,7 +205,7 @@ def make_detached_kaons_forB2JpsiX_NoMuonID( eta_min=2.0, eta_max=5.0, mipchi2dvprimary_min=9, - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), ): pvs = make_pvs() @@ -232,7 +232,7 @@ def make_detached_loose_kaons_forB2JpsiX_NoMuonID( eta_min=2.0, eta_max=5.0, mipchi2dvprimary_min=9, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): pvs = make_pvs() @@ -259,7 +259,7 @@ def make_detached_pions_forB2JpsiX_NoMuonID( eta_min=2.0, eta_max=5.0, mipchi2dvprimary_min=9, - pid=(F.PID_K < -5.0), + pid=F.conditionally_skip((F.PID_K < -5.0), label="PID"), ): pvs = make_pvs() diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_TT_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_TT_lines.py index 5ff4946bf35..1445a26c852 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_TT_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_TT_lines.py @@ -28,8 +28,8 @@ def make_jpsi_for_jpsiXTT(input_jpsi=make_detached_jpsi): F.CHI2 < 4, F.MAXSDOCA < 0.15 * mm, F.P > 10 * GeV, - F.CHILD(1, F.PID_MU) > 0, - F.CHILD(2, F.PID_MU) > 0, + F.conditionally_skip(F.CHILD(1, F.PID_MU) > 0, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_MU) > 0, label="PID"), ) return ParticleFilter( Input=input_jpsi(), Cut=F.FILTER(cut), name="bandq_filter_jpsi_for_jpsiXTT" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_lines.py index 159d8bf4319..9a72419dd4c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/b_to_jpsiX_lines.py @@ -60,8 +60,12 @@ def make_detached_jpsi_tight( if probnnmu_min > 0: code &= require_all( - F.CHILD(1, F.PROBNN_MU) > probnnmu_min, - F.CHILD(2, F.PROBNN_MU) > probnnmu_min, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_MU) > probnnmu_min, label="PROBNN" + ), + F.conditionally_skip( + F.CHILD(2, F.PROBNN_MU) > probnnmu_min, label="PROBNN" + ), ) if tight_mass: @@ -88,8 +92,12 @@ def make_detached_psi2s_tight( if probnnmu_min > 0: code &= require_all( - F.CHILD(1, F.PROBNN_MU) > probnnmu_min, - F.CHILD(2, F.PROBNN_MU) > probnnmu_min, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_MU) > probnnmu_min, label="PROBNN" + ), + F.conditionally_skip( + F.CHILD(2, F.PROBNN_MU) > probnnmu_min, label="PROBNN" + ), ) if tight_mass: @@ -115,7 +123,9 @@ def make_BuToJpsiKp_JpsiToMuMu( if process == "spruce": kaons = charged_hadrons.make_detached_kaons() elif process == "hlt2": - kaons = charged_hadrons.make_detached_kaons(pid=(F.PID_K > 1.0)) + kaons = charged_hadrons.make_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 1.0), label="PID") + ) if not psi_tight: jpsi = make_detached_jpsi() @@ -145,7 +155,9 @@ def make_BuToPsi2SKp_Psi2SToMuMu( if process == "spruce": kaons = charged_hadrons.make_detached_kaons() elif process == "hlt2": - kaons = charged_hadrons.make_detached_kaons(pid=(F.PID_K > 1.0)) + kaons = charged_hadrons.make_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 1.0), label="PID") + ) if not psi_tight: psi = make_detached_psi2s() @@ -172,7 +184,9 @@ def make_BuToJpsiPip_JpsiToMuMu( if process == "spruce": pions = charged_hadrons.make_detached_pions() elif process == "hlt2": - pions = charged_hadrons.make_detached_pions(pid=(F.PID_K < -1.0)) + pions = charged_hadrons.make_detached_pions( + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID") + ) if not psi_tight: jpsi = make_detached_jpsi() @@ -196,7 +210,9 @@ def make_BuToPsi2SPip_Psi2SToMuMu( if process == "spruce": pions = charged_hadrons.make_detached_pions() elif process == "hlt2": - pions = charged_hadrons.make_detached_pions(pid=(F.PID_K < -1.0)) + pions = charged_hadrons.make_detached_pions( + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID") + ) if not psi_tight: psi = make_detached_psi2s() @@ -220,7 +236,9 @@ def make_BdToJpsiKpPim_JpsiToMuMu( kaons = charged_hadrons.make_detached_kaons() pions = charged_hadrons.make_detached_pions() elif process == "hlt2": - kaons = charged_hadrons.make_detached_kaons(pid=(F.PID_K > 1.0)) + kaons = charged_hadrons.make_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 1.0), label="PID") + ) pions = charged_hadrons.make_detached_pions() if not psi_tight: @@ -247,7 +265,9 @@ def make_BsToJpsiKpKm_JpsiToMuMu( if process == "spruce": kaons = charged_hadrons.make_detached_kaons() elif process == "hlt2": - kaons = charged_hadrons.make_detached_kaons(pid=(F.PID_K > 1.0)) + kaons = charged_hadrons.make_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 1.0), label="PID") + ) if not psi_tight: jpsi = make_detached_jpsi() @@ -274,7 +294,9 @@ def make_LbToJpsiPKm_JpsiToMuMu( kaons = charged_hadrons.make_detached_kaons() protons = charged_hadrons.make_detached_protons() elif process == "hlt2": - kaons = charged_hadrons.make_detached_kaons(pid=(F.PID_K > 1.0)) + kaons = charged_hadrons.make_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 1.0), label="PID") + ) protons = charged_hadrons.make_detached_protons() if not psi_tight: @@ -311,7 +333,9 @@ def make_BcToJpsiPip_JpsiToMuMu( ) elif process == "hlt2": pions = charged_hadrons.make_detached_pions( - pt_min=pi_pt_min, mipchi2dvprimary_min=pi_mipchi2_min, pid=(F.PID_K < -1.0) + pt_min=pi_pt_min, + mipchi2dvprimary_min=pi_mipchi2_min, + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID"), ) if not psi_tight: @@ -348,7 +372,9 @@ def make_BcToJpsiPipPipPim_JpsiToMuMu( ) elif process == "hlt2": pions = charged_hadrons.make_detached_pions( - pt_min=pi_pt_min, mipchi2dvprimary_min=pi_mipchi2_min, pid=(F.PID_K < -1.0) + pt_min=pi_pt_min, + mipchi2dvprimary_min=pi_mipchi2_min, + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID"), ) if not psi_tight: @@ -384,7 +410,9 @@ def make_BcToJpsi5Pi_JpsiToMuMu( if process == "spruce": pions = charged_hadrons.make_detached_pions() elif process == "hlt2": - pions = charged_hadrons.make_detached_pions(pid=(F.PID_K < -1.0)) + pions = charged_hadrons.make_detached_pions( + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID") + ) if not psi_tight: jpsi = make_detached_jpsi() @@ -413,7 +441,9 @@ def make_BcToPsi2SPip_Psi2SToMuMu( if process == "spruce": pions = charged_hadrons.make_detached_pions() elif process == "hlt2": - pions = charged_hadrons.make_detached_pions(pid=(F.PID_K < -1.0)) + pions = charged_hadrons.make_detached_pions( + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID") + ) if not psi_tight: psi = make_detached_psi2s() @@ -439,7 +469,9 @@ def make_BcToPsi2SPipPipPim_Psi2SToMuMu( if process == "spruce": pions = charged_hadrons.make_detached_pions() elif process == "hlt2": - pions = charged_hadrons.make_detached_pions(pid=(F.PID_K < -1.0)) + pions = charged_hadrons.make_detached_pions( + pid=F.conditionally_skip((F.PID_K < -1.0), label="PID") + ) if not psi_tight: psi = make_detached_psi2s() diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbaryon_to_lcdsX_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbaryon_to_lcdsX_lines.py index c3534869fbc..999a9b136c3 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbaryon_to_lcdsX_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbaryon_to_lcdsX_lines.py @@ -148,7 +148,7 @@ def make_soft_pion(): mipchi2dvprimary_min=4, pt_min=200.0 * MeV, p_min=2.5 * GeV, - pid=(F.PID_K < 0.0), + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), ) @@ -159,7 +159,7 @@ def make_soft_kaon(): mipchi2dvprimary_min=4, pt_min=200.0 * MeV, p_min=2.5 * GeV, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ) @@ -170,7 +170,10 @@ def make_soft_proton(): mipchi2dvprimary_min=4, pt_min=200.0 * MeV, p_min=2.5 * GeV, - pid=require_all(F.PID_P > 0.0, F.ISMUON == 0), + pid=require_all( + F.conditionally_skip(F.PID_P > 0.0, label="PID"), + F.conditionally_skip(F.ISMUON == 0, label="ISMUON"), + ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbbar_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbbar_lines.py index 8ebaba936f1..bd8aae90d59 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbbar_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/bbbar_lines.py @@ -223,7 +223,9 @@ def make_etabToGammaGamma(name="bandq_gammagammaAlgo_{hash}"): @configurable def make_etabToPpPm(name="bandq_papAlgo_{hash}"): proton = charged_hadrons.make_prompt_protons( - p_min=20.0 * GeV, pt_min=4.5 * GeV, pid=require_all(F.PID_P > 15) + p_min=20.0 * GeV, + pt_min=4.5 * GeV, + pid=require_all(F.conditionally_skip(F.PID_P > 15, label="PID")), ) line_alg = make_etab_pppm( @@ -239,10 +241,15 @@ def make_etabToKsKpiLL(name="bandq_KsKpiLLAlgo_{hash}"): Kaon = charged_hadrons.make_prompt_kaons( pt_min=2000 * MeV, p_min=10 * GeV, - pid=require_all(F.PID_K > 10, F.PID_MU < -0.1), + pid=require_all( + F.conditionally_skip(F.PID_K > 10, label="PID"), + F.conditionally_skip(F.PID_MU < -0.1, label="PID"), + ), ) pi = charged_hadrons.make_prompt_pions( - pt_min=1500 * MeV, p_min=10 * GeV, pid=require_all(F.PID_K < -15) + pt_min=1500 * MeV, + p_min=10 * GeV, + pid=require_all(F.conditionally_skip(F.PID_K < -15, label="PID")), ) line_alg = make_etab_kskpi_LL( @@ -258,10 +265,15 @@ def make_etabToKsKpiDD(name="bandq_KsKpiDDAlgo_{hash}"): Kaon = charged_hadrons.make_prompt_kaons( pt_min=2000 * MeV, p_min=10 * GeV, - pid=require_all(F.PID_K > 10, F.PID_MU < -0.1), + pid=require_all( + F.conditionally_skip(F.PID_K > 10, label="PID"), + F.conditionally_skip(F.PID_MU < -0.1, label="PID"), + ), ) pi = charged_hadrons.make_prompt_pions( - pt_min=1500 * MeV, p_min=10 * GeV, pid=require_all(F.PID_K < -15) + pt_min=1500 * MeV, + p_min=10 * GeV, + pid=require_all(F.conditionally_skip(F.PID_K < -15, label="PID")), ) line_alg = make_etab_kskpi_DD( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons.py index c7ca970a73a..e433a3d3973 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons.py @@ -32,14 +32,16 @@ from Hlt2Conf.lines.bandq.builders import c_hadrons, charged_hadrons def make_DzToKmPip(name="bandq_DzToKmPip_{hash}", use_ProbNN=False, **decay_arguments): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=7.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=7.0) @@ -60,7 +62,8 @@ def make_DzToPimPip( ): pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=7.0) @@ -76,7 +79,8 @@ def make_DzToPimPip( def make_DzToKmKp(name="bandq_DzToKmKp_{hash}", use_ProbNN=False, **decay_arguments): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=7.0) @@ -91,14 +95,16 @@ def make_DzToKmKp(name="bandq_DzToKmKp_{hash}", use_ProbNN=False, **decay_argume def make_DzToKm3Pi(name="bandq_DzToKm3Pi_{hash}", use_ProbNN=False, **decay_arguments): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=4.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=4.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=4.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=4.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=4.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=4.0) @@ -117,14 +123,16 @@ def make_DzToKm3Pi_tightip( ): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=12.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=12.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=12.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=12.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=12.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=12.0) @@ -176,14 +184,16 @@ def make_DpToKmPipPip( ): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=7.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=7.0) @@ -209,14 +219,16 @@ def make_DstarpToKmPipPip( ): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=7.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=7.0) @@ -242,14 +254,16 @@ def make_DspToKmKpPip( ): kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=7.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=7.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=7.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=7.0) @@ -275,21 +289,24 @@ def make_LcToPpKmPip( ): protons = ( charged_hadrons.make_detached_protons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_P > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_P > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_protons(mipchi2dvprimary_min=5.0) ) kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=5.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=5.0) @@ -313,21 +330,24 @@ def make_LcToPpKmPip( def make_XicpToPpKmPip(name="bandq_XicpToPpKmPip_{hash}", use_ProbNN=False): protons = ( charged_hadrons.make_detached_protons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_P > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_P > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_protons(mipchi2dvprimary_min=5.0) ) kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=5.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=5.0) @@ -350,21 +370,24 @@ def make_XicpToPpKmPip(name="bandq_XicpToPpKmPip_{hash}", use_ProbNN=False): def make_XiczToPpKmKmPip(name="bandq_XiczToPpKmKmPip_{hash}", use_ProbNN=False): protons = ( charged_hadrons.make_detached_protons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_P > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_P > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_protons(mipchi2dvprimary_min=5.0) ) kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=5.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=5.0) @@ -387,21 +410,24 @@ def make_XiczToPpKmKmPip(name="bandq_XiczToPpKmKmPip_{hash}", use_ProbNN=False): def make_OmegaczToPpKmKmPip(name="bandq_OmegaczToPpKmKmPip_{hash}", use_ProbNN=False): protons = ( charged_hadrons.make_detached_protons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_P > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_P > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_protons(mipchi2dvprimary_min=5.0) ) kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=5.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=5.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=5.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=5.0) @@ -421,21 +447,24 @@ def make_TightOmegaczToPpKmKmPip( ): protons = ( charged_hadrons.make_detached_protons( - mipchi2dvprimary_min=4.0, pid=F.PROBNN_P > 0.1 + mipchi2dvprimary_min=4.0, + pid=F.conditionally_skip(F.PROBNN_P > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_protons(mipchi2dvprimary_min=4.0) ) kaons = ( charged_hadrons.make_detached_kaons( - mipchi2dvprimary_min=4.0, pid=F.PROBNN_K > 0.1 + mipchi2dvprimary_min=4.0, + pid=F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_kaons(mipchi2dvprimary_min=4.0) ) pions = ( charged_hadrons.make_detached_pions( - mipchi2dvprimary_min=4.0, pid=F.PROBNN_PI > 0.1 + mipchi2dvprimary_min=4.0, + pid=F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), ) if use_ProbNN else charged_hadrons.make_detached_pions(mipchi2dvprimary_min=4.0) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons_forDoubleCharm.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons_forDoubleCharm.py index 283610145f8..05b7697baf9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons_forDoubleCharm.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/c_to_hadrons_forDoubleCharm.py @@ -41,14 +41,14 @@ def make_doublecharm_DzToHH(descriptor, **decay_arguments): mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_min, pt_min=250.0 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) kaons = charged_hadrons.make_detached_kaons( mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_min, pt_min=250.0 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) particles = [] @@ -96,14 +96,14 @@ def make_doublecharm_DzToHHHH(descriptor, **decay_arguments): pt_min=250 * MeV, p_min=3.2 * GeV, ghostProb_max=charm_daughters_ghostprob_doublecharm_max, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ) kaons = charged_hadrons.make_detached_kaons( mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_min, pt_min=250 * MeV, p_min=3.2 * GeV, ghostProb_max=charm_daughters_ghostprob_doublecharm_max, - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), ) particles = [] name = "" @@ -291,7 +291,10 @@ def make_doublecharm_LcToPpKmPip( ): protons = charged_hadrons.make_detached_protons( pt_min=500 * MeV, - pid=F.require_all(((F.PID_P - F.PID_K) > 0), (F.PID_P > 0)), + pid=F.require_all( + F.conditionally_skip(((F.PID_P - F.PID_K) > 0), label="PID"), + F.conditionally_skip((F.PID_P > 0), label="PID"), + ), mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_baryon_min, ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) @@ -328,7 +331,10 @@ def make_doublecharm_XicpToPpKmPip( ): protons = charged_hadrons.make_detached_protons( pt_min=500 * MeV, - pid=F.require_all(((F.PID_P - F.PID_K) > 0), (F.PID_P > 0)), + pid=F.require_all( + F.conditionally_skip(((F.PID_P - F.PID_K) > 0), label="PID"), + F.conditionally_skip((F.PID_P > 0), label="PID"), + ), mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_baryon_min, ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) @@ -364,7 +370,10 @@ def make_doublecharm_XiczToPpKmKmPip( ): protons = charged_hadrons.make_detached_protons( pt_min=500 * MeV, - pid=F.require_all(((F.PID_P - F.PID_K) > 0), (F.PID_P > 0)), + pid=F.require_all( + F.conditionally_skip(((F.PID_P - F.PID_K) > 0), label="PID"), + F.conditionally_skip((F.PID_P > 0), label="PID"), + ), mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_baryon_min, ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) @@ -400,7 +409,10 @@ def make_doublecharm_OmegaczToPpKmKmPip( ): protons = charged_hadrons.make_detached_protons( pt_min=500 * MeV, - pid=F.require_all(((F.PID_P - F.PID_K) > 0), (F.PID_P > 0)), + pid=F.require_all( + F.conditionally_skip(((F.PID_P - F.PID_K) > 0), label="PID"), + F.conditionally_skip((F.PID_P > 0), label="PID"), + ), mipchi2dvprimary_min=charm_daughters_mipchi2_doublecharm_baryon_min, ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) @@ -467,14 +479,14 @@ def make_DzToKsLLHH(descriptor): mipchi2dvprimary_min=7.0, pt_min=250 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) kaons = charged_hadrons.make_detached_kaons( mipchi2dvprimary_min=7.0, pt_min=250 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) ksLL = longlived_hadrons.make_KsLL_tight() @@ -529,14 +541,14 @@ def make_DzToKsDDHH(descriptor): mipchi2dvprimary_min=7.0, pt_min=250 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) kaons = charged_hadrons.make_detached_kaons( mipchi2dvprimary_min=7.0, pt_min=250 * MeV, p_min=3.2 * GeV, - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), ghostProb_max=charm_daughters_ghostprob_doublecharm_max, ) ksDD = longlived_hadrons.make_KsDD_tight() diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/charged_hadrons.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/charged_hadrons.py index 8851335de58..72723ff80a1 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/charged_hadrons.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/charged_hadrons.py @@ -77,7 +77,7 @@ def make_detached_pions( mipchi2dvprimary_min=4.0, pt_min=200.0 * MeV, p_min=2.5 * GeV, - pid=(F.PID_K < 0.0), + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), ghostProb_max=None, **decay_arguments, ): @@ -102,7 +102,7 @@ def make_detached_pions_soft( mipchi2dvprimary_min=4.0, pt_min=100.0 * MeV, p_min=2.0 * GeV, - pid=(F.PID_K < 0.0), + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), **decay_arguments, ): """ @@ -122,7 +122,7 @@ def make_detached_pions_soft( @configurable def make_detached_pions_tightpid( name="bandq_detached_pions_tightpid_{hash}", - pid=(F.PID_K < -5), + pid=F.conditionally_skip((F.PID_K < -5), label="PID"), pt_min=200.0 * MeV, ghostProb_max=None, ): @@ -148,7 +148,7 @@ def make_detached_down_pions( mipchi2dvprimary_min=100.0, pt_min=400.0 * MeV, p_min=2.5 * GeV, - pid=(F.PID_K < 0.0), + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), ghostProb_max=None, **decay_arguments, ): @@ -190,7 +190,7 @@ def make_detached_kaons( mipchi2dvprimary_min=4.0, pt_min=200.0 * MeV, p_min=2.5 * GeV, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ghostProb_max=None, **decay_arguments, ): @@ -215,7 +215,7 @@ def make_detached_kaons_tightpt( mipchi2dvprimary_min=4.0, pt_min=500.0 * MeV, p_min=2.5 * GeV, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), **decay_arguments, ): """ @@ -235,7 +235,7 @@ def make_detached_kaons_tightpt( @configurable def make_detached_kaons_tightpid( name="bandq_detached_kaons_tightpid_{hash}", - pid=(F.PID_K > 5), + pid=F.conditionally_skip((F.PID_K > 5), label="PID"), pt_min=200 * MeV, ghostProb_max=None, ): @@ -261,7 +261,7 @@ def make_detached_protons( mipchi2dvprimary_min=4.0, pt_min=200.0 * MeV, p_min=10.0 * GeV, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ghostProb_max=None, **decay_arguments, ): @@ -283,7 +283,7 @@ def make_detached_protons( @configurable def make_detached_protons_tightpid( name="bandq_detached_protons_tightpid_{hash}", - pid=(F.PID_P > 5), + pid=F.conditionally_skip((F.PID_P > 5), label="PID"), pt_min=200 * MeV, ghostProb_max=None, ): @@ -311,7 +311,7 @@ def make_detached_protons_tightpid( @configurable def make_prompt_pions( name="bandq_prompt_pions_{hash}", - pid=(F.PID_K < 0.0), + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), pt_min=200.0 * MeV, p_min=2.5 * GeV, **decay_arguments, @@ -332,7 +332,7 @@ def make_prompt_pions( @configurable def make_prompt_kaons( name="bandq_prompt_kaons_{hash}", - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), pt_min=200.0 * MeV, p_min=2.5 * GeV, **decay_arguments, @@ -355,7 +355,7 @@ def make_prompt_protons( name="bandq_prompt_protons_{hash}", p_min=10.0 * GeV, pt_min=200.0 * MeV, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), **decay_arguments, ): """ @@ -443,7 +443,7 @@ def make_spruce_detached_tight_pions( name="bandq_spruce_detached_tight_pions_{hash}", pt_min=0.5 * GeV, p_min=5 * GeV, - pid=F.PROBNN_PI > 0.2, + pid=F.conditionally_skip(F.PROBNN_PI > 0.2, label="PROBNN"), ghostProb_max=0.4, trackChi2Ndof_max=3.0, mipchi2dvprimary_min=6.0, @@ -467,7 +467,7 @@ def make_spruce_detached_tight_kaons( name="bandq_spruce_detached_tight_kaons_{hash}", pt_min=0.5 * GeV, p_min=5 * GeV, - pid=F.PROBNN_K > 0.2, + pid=F.conditionally_skip(F.PROBNN_K > 0.2, label="PROBNN"), ghostProb_max=0.4, trackChi2Ndof_max=3.0, mipchi2dvprimary_min=6.0, @@ -491,7 +491,7 @@ def make_spruce_detached_tight_protons( name="bandq_spruce_detached_tight_protons_{hash}", pt_min=0.5 * GeV, p_min=10 * GeV, - pid=F.PROBNN_P > 0.2, + pid=F.conditionally_skip(F.PROBNN_P > 0.2, label="PROBNN"), ghostProb_max=0.4, trackChi2Ndof_max=3.0, mipchi2dvprimary_min=6.0, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/jpsi_to_lmdlmd_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/jpsi_to_lmdlmd_lines.py index 924663faaa5..a2a321086a8 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/jpsi_to_lmdlmd_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/jpsi_to_lmdlmd_lines.py @@ -45,14 +45,17 @@ def make_lambdall(): mipchi2dvprimary_min=20.0, pt_min=100.0 * MeV, p_min=2.0 * GeV, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ) protons = make_detached_protons( name="bandq_deteached_protons_for_lmd_ll_{hash}", mipchi2dvprimary_min=10.0, pt_min=400.0 * MeV, p_min=9.0 * GeV, - pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 0.0, label="PID"), + ), ) combinationcode = F.require_all( in_range(1095 * MeV, F.MASS, 1140 * MeV), @@ -92,7 +95,10 @@ def make_lambdadd(): mipchi2dvprimary_min=6.0, pt_min=1200 * MeV, p_min=8.0 * GeV, - pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 0.0, label="PID"), + ), ) combinationcode = F.require_all( in_range(1085 * MeV, F.MASS, 1145 * MeV), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/longlived_hadrons.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/longlived_hadrons.py index 64c9365fc00..39eed8fd3dd 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/longlived_hadrons.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/longlived_hadrons.py @@ -100,7 +100,7 @@ def make_KsLL_tight( mipchi2dvprimary_min=16.0, pt_min=0.0, p_min=0.0, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ) return ParticleCombiner( [pions, pions], @@ -142,7 +142,7 @@ def make_KsDD_tight( name="bandq_KsDD_pions_{hash}", pt_min=175 * MeV, p_min=3.0 * GeV, - pid=(F.PID_K < 5.0), + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ) return ParticleCombiner( [pions, pions], @@ -218,7 +218,8 @@ def make_Lambda_fromLongLived( @configurable def make_pion_fromLongLived( - name="bandq_pion_fromLongLived_{hash}", pid=(F.PID_K < 5.0) + name="bandq_pion_fromLongLived_{hash}", + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ): if nopid_hadrons(): cut_pid = None @@ -231,7 +232,8 @@ def make_pion_fromLongLived( @configurable def make_kaon_fromLongLived( - name="bandq_kaon_fromLongLived_{hash}", pid=(F.PID_K < 5.0) + name="bandq_kaon_fromLongLived_{hash}", + pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ): if nopid_hadrons(): cut_pid = None diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/neutral_particles.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/neutral_particles.py index 772877899a9..da06db43370 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/neutral_particles.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/neutral_particles.py @@ -59,8 +59,8 @@ def make_bandq_photons_verytight( cut = F.require_all( F.ENERGY > e_min, F.PT > pt_min, - F.IS_PHOTON > isg_min, - F.IS_NOT_H > isnoth_min, + F.conditionally_skip(F.IS_PHOTON > isg_min, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > isnoth_min, label="IS_NOT_H"), F.CALO_NEUTRAL_4TO9_ENERGY_RATIO > E4To9_min, F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > E1To9_min, ) @@ -87,7 +87,9 @@ def _make_gamma2ee( # code to make converted photons with brem added and apply some loose selection electron_code = F.require_all(F.PT > pt_e_min, F.P > p_e_min) if not nopid_electrons(): - electron_code &= F.PID_E > pid_e_threshold_all + electron_code &= F.conditionally_skip( + F.PID_E > pid_e_threshold_all, label="PID" + ) filtered_electrons = ParticleFilter( electrons, F.FILTER(electron_code), name=electron_name ) @@ -104,8 +106,12 @@ def _make_gamma2ee( ) if pid_e_threshold_any and not nopid_electrons(): code_dielectron &= F.require_any( - F.CHILD(1, F.PID_E) > pid_e_threshold_any, - F.CHILD(2, F.PID_E) > pid_e_threshold_any, + F.conditionally_skip( + F.CHILD(1, F.PID_E) > pid_e_threshold_any, label="PID" + ), + F.conditionally_skip( + F.CHILD(2, F.PID_E) > pid_e_threshold_any, label="PID" + ), ) return ParticleFilter( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/ppmumu_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/ppmumu_lines.py index 5c463cdd4b3..b23e61c5e02 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/ppmumu_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/ppmumu_lines.py @@ -40,7 +40,7 @@ def make_ppmumu_basic_muon( code = F.require_all(F.PT > minPt_muon) if not nopid_muons(): - code &= F.require_all(F.PID_MU > minPIDmu) + code &= F.require_all(F.conditionally_skip(F.PID_MU > minPIDmu, label="PID")) return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -55,7 +55,7 @@ def make_ppmumu_basic_proton( code = F.require_all(F.PT > minPt_proton) if not nopid_hadrons(): - code &= F.require_all(F.PID_P > minPIDp) + code &= F.require_all(F.conditionally_skip(F.PID_P > minPIDp, label="PID")) return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -77,7 +77,7 @@ def make_ppmumu_Hc_muon( code = F.require_all(F.OWNPVIPCHI2 < mipchi2dvprimary_max) if not nopid_muons(): - code &= F.require_all(F.PID_MU > minPIDmu) + code &= F.require_all(F.conditionally_skip(F.PID_MU > minPIDmu, label="PID")) return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -92,7 +92,7 @@ def make_ppmumu_Hc_proton( code = F.require_all(F.OWNPVIPCHI2 < mipchi2dvprimary_max) if not nopid_hadrons(): - code &= F.require_all(F.PID_P > minPIDp) + code &= F.require_all(F.conditionally_skip(F.PID_P > minPIDp, label="PID")) return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -142,7 +142,7 @@ def make_ppmumu_High_muon( code = F.require_all(F.OWNPVIPCHI2 < mipchi2dvprimary_max, F.PT > minPt_muon) if not nopid_muons(): - code &= F.require_all(F.PID_MU > minPIDmu) + code &= F.require_all(F.conditionally_skip(F.PID_MU > minPIDmu, label="PID")) return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -158,7 +158,7 @@ def make_ppmumu_High_proton( code = F.require_all(F.OWNPVIPCHI2 < mipchi2dvprimary_max, F.PT > minPt_proton) if not nopid_hadrons(): - code &= F.require_all(F.PID_P > minPIDp) + code &= F.require_all(F.conditionally_skip(F.PID_P > minPIDp, label="PID")) return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/qqbar_to_hadrons.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/qqbar_to_hadrons.py index 599c6a995b1..c3f11352964 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/qqbar_to_hadrons.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/qqbar_to_hadrons.py @@ -345,7 +345,10 @@ def make_detached_ccbarToPpPm( ##### Default detached ccbar to ppbar ): protons = make_detached_protons( pt_min=pt_min_proton, - pid=F.require_all(F.PID_P > pid_p_min, (F.PID_P - F.PID_K) > pid_p_k_min), + pid=F.require_all( + F.conditionally_skip(F.PID_P > pid_p_min, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > pid_p_k_min, label="PID"), + ), ghostProb_max=ghostProb_max, ) return make_ccbar_to_hadrons( @@ -377,7 +380,10 @@ def make_prompt_ccbarToPpPm( ##### Default prompt ccbar to ppbar ): protons = make_prompt_protons( pt_min=pt_min_proton, - pid=F.require_all(F.PID_P > 20.0, (F.PID_P - F.PID_K) > 10.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 20.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 10.0, label="PID"), + ), ) return make_ccbar_to_hadrons( name=name, @@ -764,7 +770,10 @@ def make_detached_ccbarToPpPm_spruce( ##### Default detached ccbar to ppbar spr ): protons = make_detached_protons( pt_min=pt_min_proton, - pid=F.require_all(F.PID_P > pid_p_min, (F.PID_P - F.PID_K) > pid_p_k_min), + pid=F.require_all( + F.conditionally_skip(F.PID_P > pid_p_min, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > pid_p_k_min, label="PID"), + ), ) return make_ccbar_to_hadrons( name=name, @@ -790,7 +799,11 @@ def make_prompt_ccbarToPpPmHigh( ##### High mass prompt ccbar to ppbar m_max=5000 * MeV, ): protons = make_prompt_protons( - pt_min=1900 * MeV, pid=F.require_all(F.PID_P > 20.0, (F.PID_P - F.PID_K) > 10.0) + pt_min=1900 * MeV, + pid=F.require_all( + F.conditionally_skip(F.PID_P > 20.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 10.0, label="PID"), + ), ) return make_ccbar_to_hadrons( name=name, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/sexaquark_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/sexaquark_lines.py index 106a2637d6b..52ff7d6b280 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/sexaquark_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/sexaquark_lines.py @@ -87,7 +87,7 @@ def filter_protons( ): cut = require_all( F.PT > pt_min, - F.PROBNN_P > pid_p_min, + F.conditionally_skip(F.PROBNN_P > pid_p_min, label="PROBNN"), F.GHOSTPROB < ghostProb_max, F.OWNPVIPCHI2 > mipchi2dvprimary_min, ) @@ -210,12 +210,12 @@ def make_bbaryontopmDsp( kaons = make_detached_kaons( pt_min=_KfromD_PT * MeV, ghostProb_max=_KfromD_ProbNNghost, - pid=(F.PROBNN_K > _KfromD_ProbNNk), + pid=F.conditionally_skip((F.PROBNN_K > _KfromD_ProbNNk), label="PROBNN"), ) pions = make_detached_pions( pt_min=_pifromD_PT, ghostProb_max=_pifromD_ProbNNghost, - pid=(F.PROBNN_PI > _pifromD_ProbNNpi), + pid=F.conditionally_skip((F.PROBNN_PI > _pifromD_ProbNNpi), label="PROBNN"), ) anti_protons = filter_protons(make_long_protons()) @@ -261,12 +261,12 @@ def make_bbaryontopmDp( kaons = make_detached_kaons( pt_min=_KfromD_PT * MeV, ghostProb_max=_KfromD_ProbNNghost, - pid=(F.PROBNN_K > _KfromD_ProbNNk), + pid=F.conditionally_skip((F.PROBNN_K > _KfromD_ProbNNk), label="PROBNN"), ) pions = make_detached_pions( pt_min=_pifromD_PT, ghostProb_max=_pifromD_ProbNNghost, - pid=(F.PROBNN_PI > _pifromD_ProbNNpi), + pid=F.conditionally_skip((F.PROBNN_PI > _pifromD_ProbNNpi), label="PROBNN"), ) anti_protons = filter_protons(make_long_protons()) @@ -312,12 +312,12 @@ def make_bbaryontopmDz( kaons = make_detached_kaons( pt_min=_KfromD_PT * MeV, ghostProb_max=_KfromD_ProbNNghost, - pid=(F.PROBNN_K > _KfromD_ProbNNk), + pid=F.conditionally_skip((F.PROBNN_K > _KfromD_ProbNNk), label="PROBNN"), ) pions = make_detached_pions( pt_min=_pifromD_PT, ghostProb_max=_pifromD_ProbNNghost, - pid=(F.PROBNN_PI > _pifromD_ProbNNpi), + pid=F.conditionally_skip((F.PROBNN_PI > _pifromD_ProbNNpi), label="PROBNN"), ) anti_protons = filter_protons(make_long_protons()) @@ -363,12 +363,12 @@ def make_bbaryontopDz( kaons = make_detached_kaons( pt_min=_KfromD_PT * MeV, ghostProb_max=_KfromD_ProbNNghost, - pid=(F.PROBNN_K > _KfromD_ProbNNk), + pid=F.conditionally_skip((F.PROBNN_K > _KfromD_ProbNNk), label="PROBNN"), ) pions = make_detached_pions( pt_min=_pifromD_PT, ghostProb_max=_pifromD_ProbNNghost, - pid=(F.PROBNN_PI > _pifromD_ProbNNpi), + pid=F.conditionally_skip((F.PROBNN_PI > _pifromD_ProbNNpi), label="PROBNN"), ) anti_protons = filter_protons(make_long_protons()) @@ -460,7 +460,7 @@ def make_bbaryontopmKp_Sig(): kaons_forpK = make_detached_kaons( mipchi2dvprimary_min=_K_IPchi2, pt_min=_K_PT, - pid=(F.PROBNN_K > _K_ProbNNk), + pid=F.conditionally_skip((F.PROBNN_K > _K_ProbNNk), label="PROBNN"), ghostProb_max=_K_ProbNNghost, ) @@ -483,7 +483,7 @@ def make_bbaryontopmKp_Control(): kaons_forpK = make_detached_kaons( mipchi2dvprimary_min=_K_IPchi2, pt_min=_K_PT, - pid=(F.PROBNN_K > _K_ProbNNk), + pid=F.conditionally_skip((F.PROBNN_K > _K_ProbNNk), label="PROBNN"), ghostProb_max=_K_ProbNNghost, ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/tcc_exclusive.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/tcc_exclusive.py index d2153343123..97af36ff0d7 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/tcc_exclusive.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bandq/builders/tcc_exclusive.py @@ -40,7 +40,9 @@ def tcc_make_soft_pions(process): F.require_all( F.PT > 150 * MeV, F.P > 1.5 * GeV, - F.PID_K < 5 if process == "hlt2" else F.PROBNN_PI > 0.1, + F.conditionally_skip(F.PID_K < 5, label="PID") + if process == "hlt2" + else F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), F.CHI2DOF < 3.5, F.GHOSTPROB < 0.4, ), @@ -57,7 +59,9 @@ def tcc_make_charm_pions(process): F.OWNPVIPCHI2 > 4.0, F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5 if process == "hlt2" else F.PROBNN_PI > 0.1, + F.conditionally_skip(F.PID_K < 5, label="PID") + if process == "hlt2" + else F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), F.CHI2DOF < 3.5, F.GHOSTPROB < 0.4, ), @@ -74,7 +78,9 @@ def tcc_make_charm_kaons(process): F.OWNPVIPCHI2 > 4.0, F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5 if process == "hlt2" else F.PROBNN_K > 0.1, + F.conditionally_skip(F.PID_K > 5, label="PID") + if process == "hlt2" + else F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), F.CHI2DOF < 3.5, F.GHOSTPROB < 0.4, ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_phhh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_phhh.py index 9fb45ddd1f0..c8dc473b978 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_phhh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_phhh.py @@ -307,7 +307,10 @@ def make_Lb0ToPpPmPmDeutp(process): deuterons = make_bbaryon_detached_deuterons() elif process == "hlt2": protons = make_bbaryon_detached_protons( - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > -5)) + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > -5), label="PID") + ) ) deuterons = make_bbaryon_detached_deuterons(pid=None) line_alg = make_bbaryon_4body( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_pppph.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_pppph.py index 86d0a8770cb..5715a4365ac 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_pppph.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/bbaryon_to_pppph.py @@ -47,7 +47,10 @@ def make_BuToPpPpPmPmPip(process): if process == "hlt2": pions = make_bbaryon_detached_pions() protons = make_bbaryon_detached_protons( - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > -5)) + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > -5), label="PID") + ) ) elif process == "spruce": pions = make_bbaryon_detached_pions(pid=None) @@ -64,9 +67,14 @@ def make_BuToPpPpPmPmPip(process): @check_process def make_BuToPpPpPmPmKp(process): if process == "hlt2": - kaons = make_bbaryon_detached_kaons(pid=(F.PID_K > 3.0)) + kaons = make_bbaryon_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 3.0), label="PID") + ) protons = make_bbaryon_detached_protons( - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > -5)) + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > -5), label="PID") + ) ) elif process == "spruce": kaons = make_bbaryon_detached_kaons(pid=None) @@ -85,7 +93,10 @@ def make_Lb0ToPpPpPpPmPmPim(process): if process == "hlt2": pions = make_bbaryon_detached_pions() protons = make_bbaryon_detached_protons( - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > -5)) + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > -5), label="PID") + ) ) elif process == "spruce": pions = make_bbaryon_detached_pions(pid=None) @@ -101,9 +112,14 @@ def make_Lb0ToPpPpPpPmPmPim(process): @check_process def make_Lb0ToPpPpPpPmPmKm(process): if process == "hlt2": - kaons = make_bbaryon_detached_kaons(pid=(F.PID_K > 3.0)) + kaons = make_bbaryon_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 3.0), label="PID") + ) protons = make_bbaryon_detached_protons( - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > -5)) + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > -5), label="PID") + ) ) elif process == "spruce": kaons = make_bbaryon_detached_kaons(pid=None) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/b_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/b_builder.py index 4ad4cae3746..ed122918b63 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/b_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/b_builder.py @@ -1132,12 +1132,16 @@ def make_bds2ppbarppbar( b_min_fdchi2=100, MinimalPidProtonCut=0.01, ): - MinimalPid4Proton = ( - F.CHILD(1, F.PROBNN_P) - * F.CHILD(2, F.PROBNN_P) - * F.CHILD(3, F.PROBNN_P) - * F.CHILD(4, F.PROBNN_P) - ) > MinimalPidProtonCut + MinimalPid4Proton = F.conditionally_skip( + ( + F.CHILD(1, F.PROBNN_P) + * F.CHILD(2, F.PROBNN_P) + * F.CHILD(3, F.PROBNN_P) + * F.CHILD(4, F.PROBNN_P) + ) + > MinimalPidProtonCut, + label="PROBNN", + ) combination12_code = F.require_all( F.MAXSDOCACHI2CUT(sdocachi2_max), @@ -1199,7 +1203,10 @@ def make_bds2ppbar( in_range(am_min_mass, F.MASS, am_max_mass), F.MAX(F.PT) > comb_max_pt, F.MAX(F.OWNPVIPCHI2) > am_max_ipchi2, - F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > MinimalPidProtonCut, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > MinimalPidProtonCut, + label="PROBNN", + ), ) vertex_code = F.require_all( @@ -1580,7 +1587,7 @@ def make_bTo5K( ): comb12_code = F.require_all( F.MASS < am12_max, - F.MIN(F.PID_K) > minpidk12_min, + F.conditionally_skip(F.MIN(F.PID_K) > minpidk12_min, label="PID"), F.MIN(F.PT) > minpt12_min, F.MIN(F.OWNPVIPCHI2) > minipchi212_min, F.MAX(F.PT) > maxpt12_min, @@ -1591,7 +1598,7 @@ def make_bTo5K( comb1234_code = F.require_all( F.MASS < am1234_max, F.MAXSDOCACUT(sdoca1234_max), - F.CHILD(4, F.PID_K) > osk1pidk_min, + F.conditionally_skip(F.CHILD(4, F.PID_K) > osk1pidk_min, label="PID"), F.CHILD(4, F.PT) > osk1pt_min, F.CHILD(4, F.OWNPVIPCHI2) > osk1ipchi2_min, ) @@ -1600,7 +1607,10 @@ def make_bTo5K( F.PT > apt_min, F.MAXSDOCACUT(sdoca_max), F.SUM(F.OWNPVIPCHI2 > 4) > nipchi2_gt_4_min, - F.SUM(F.PID_K > 0) > npidk_gt_0_min, + F.conditionally_skip( + F.SUM(F.conditionally_skip(F.PID_K > 0, label="PID")) > npidk_gt_0_min, + label="PID", + ), ) vertex_code = F.require_all( F.math.in_range(m_min, F.MASS, m_max), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/basic_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/basic_builder.py index 971bbf4359f..381277cb99e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/basic_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/bnoc/builders/basic_builder.py @@ -84,9 +84,9 @@ def make_pions( trghostprob_max=trghostprob_max, ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") if invert_pid: - code = F.PID_K > pi_pidk_max + code = F.conditionally_skip(F.PID_K > pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -113,7 +113,7 @@ def make_down_pions( trghostprob_max=trghostprob_max, ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -138,9 +138,9 @@ def make_tight_pions( trghostprob_max=trghostprob_max, ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") if invert_pid: - code = F.PID_K > pi_pidk_max + code = F.conditionally_skip(F.PID_K > pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -163,11 +163,15 @@ def make_verytight_pions( pt_min=pt_min, mipchi2_min=mipchi2_min, ) - code = F.require_all(F.ISMUON == is_muon) + code = F.require_all(F.conditionally_skip(F.ISMUON == is_muon, label="ISMUON")) if pi_pidk_max is not None: - code = F.require_all(code, F.PID_K < pi_pidk_max) + code = F.require_all( + code, F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") + ) if pi_pidp_max is not None: - code = F.require_all(code, F.PID_P < pi_pidp_max) + code = F.require_all( + code, F.conditionally_skip(F.PID_P < pi_pidp_max, label="PID") + ) if chi2dof_max is not None: code = F.require_all(code, F.CHI2DOF < chi2dof_max) if ghostprob_max is not None: @@ -196,9 +200,9 @@ def make_soft_pions( trghostprob_max=trghostprob_max, ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") if invert_pid: - code = F.PID_K > pi_pidk_max + code = F.conditionally_skip(F.PID_K > pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -220,13 +224,15 @@ def make_PionsforB2ppbarhh( p_min=p_min, pt_min=pt_min, ) - code = F.ISMUON == is_muon + code = F.conditionally_skip(F.ISMUON == is_muon, label="ISMUON") if track_chisquareperdof_max is not None: code &= F.CHI2DOF < track_chisquareperdof_max if pi_pidk_max is not None: - code &= F.PID_K < pi_pidk_max + code &= F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") if pi_pidp_max is not None: - code = F.require_all(code, F.PID_P < pi_pidp_max) + code = F.require_all( + code, F.conditionally_skip(F.PID_P < pi_pidp_max, label="PID") + ) pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -242,7 +248,7 @@ def make_detached_pions( make_particles=make_long_pions_for_V0, p_min=p_min, mipchi2_min=mipchi2_min ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -265,9 +271,9 @@ def make_kaons( trghostprob_max=trghostprob_max, ) if k_pidk_min is not None: - code = F.PID_K > k_pidk_min + code = F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") if invert_pid: - code = F.PID_K < k_pidk_min + code = F.conditionally_skip(F.PID_K < k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -292,9 +298,9 @@ def make_tight_kaons( trghostprob_max=trghostprob_max, ) if k_pidk_min is not None: - code = F.PID_K > k_pidk_min + code = F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") if invert_pid: - code = F.PID_K < k_pidk_min + code = F.conditionally_skip(F.PID_K < k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -319,9 +325,9 @@ def make_soft_kaons( trghostprob_max=trghostprob_max, ) if k_pidk_min is not None: - code = F.PID_K > k_pidk_min + code = F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") if invert_pid: - code = F.PID_K < k_pidk_min + code = F.conditionally_skip(F.PID_K < k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -342,11 +348,11 @@ def make_KaonsforB2ppbarhh( p_min=p_min, pt_min=pt_min, ) - code = F.ISMUON == is_muon + code = F.conditionally_skip(F.ISMUON == is_muon, label="ISMUON") if track_chisquareperdof_max is not None: code &= F.CHI2DOF < track_chisquareperdof_max if k_pidk_min is not None: - code &= F.PID_K > k_pidk_min + code &= F.conditionally_skip(F.PID_K > k_pidk_min, label="PID") kaons = ParticleFilter(kaons, F.FILTER(code)) return kaons @@ -358,7 +364,7 @@ def make_protons(p_pidp_min=-5, p_min=1 * GeV, pt_min=250 * MeV): make_particles=make_has_rich_long_protons, p_min=p_min, pt_min=pt_min ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -373,7 +379,7 @@ def make_tight_protons(p_pidp_min=0, p_min=1.5 * GeV, pt_min=500 * MeV, mipchi2_ mipchi2_min=mipchi2_min, ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -388,7 +394,7 @@ def make_soft_protons(p_pidp_min=-10, p_min=1 * GeV, pt_min=100 * MeV, mipchi2_m pt_min=pt_min, ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -410,13 +416,13 @@ def make_ProtonsforB2ppbarhh( p_min=p_min, pt_min=pt_min, ) - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") if is_muon is not None: - code &= F.ISMUON == is_muon + code &= F.conditionally_skip(F.ISMUON == is_muon, label="ISMUON") if track_chisquareperdof_max is not None: code &= F.CHI2DOF < track_chisquareperdof_max if p_pid_pkdiff is not None: - code &= F.PID_P - F.PID_K > p_pid_pkdiff + code &= F.conditionally_skip(F.PID_P - F.PID_K > p_pid_pkdiff, label="PID") protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -437,7 +443,7 @@ def make_detached_protons( mipchi2_min=mipchi2_min, ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -473,7 +479,7 @@ def make_bbaryon_filter_tracks( code &= F.MINIPCHI2(pvs) > mipchi2dvprimary_min if notmuon is True: - code &= ~F.ISMUON + code &= F.conditionally_skip(~F.ISMUON, label="ISMUON") return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -487,7 +493,7 @@ def make_bbaryon_detached_pions( p_min=1.5 * GeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=11.0, # TBC - pid=(F.PID_K < 1.0), + pid=F.conditionally_skip((F.PID_K < 1.0), label="PID"), ): """ Return bnoc b-baryon detached pions. @@ -508,7 +514,10 @@ def make_bbaryon_detached_kaons( p_min=1.5 * GeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=11.0, # TBC - pid=((F.PID_K > 3.0) & (F.PID_K - F.PID_P > -2)), + pid=( + F.conditionally_skip((F.PID_K > 3.0), label="PID") + & F.conditionally_skip((F.PID_K - F.PID_P > -2), label="PID") + ), ): """ Return bnoc b-baryon detached kaons. @@ -529,7 +538,11 @@ def make_bbaryon_detached_protons( p_min=1.5 * GeV, pt_min=500.0 * MeV, mipchi2dvprimary_min=11.0, # TBC - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > 0) & (F.PROBNN_P > 0.05)), + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > 0), label="PID") + & F.conditionally_skip((F.PROBNN_P > 0.05), label="PROBNN") + ), ): """ Return bnoc b-baryon detached protons. @@ -549,7 +562,7 @@ def make_bbaryon_detached_deuterons( p_min=1.5 * GeV, pt_min=500.0 * MeV, mipchi2dvprimary_min=11.0, # TBC - pid=(F.PID_P > 3.0), + pid=F.conditionally_skip((F.PID_P > 3.0), label="PID"), ): """ Return bnoc b-baryon detached deuterons. @@ -591,7 +604,7 @@ def make_bbaryon_soft_pions( p_min=2.0 * GeV, pt_min=200.0 * MeV, mipchi2dvprimary_min=6.0, - pid=(F.PID_K < 0.0), + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), ): """ Return bnoc b-baryon soft pions. @@ -612,7 +625,7 @@ def make_bbaryon_soft_kaons( p_min=2.0 * GeV, pt_min=200.0 * MeV, mipchi2dvprimary_min=6.0, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): """ Return bnoc b-baryon soft kaons. @@ -633,7 +646,10 @@ def make_bbaryon_soft_protons( p_min=8.5 * GeV, pt_min=200.0 * MeV, mipchi2dvprimary_min=6.0, - pid=((F.PID_P > 3.0) & (F.PID_P - F.PID_K > -5)), + pid=( + F.conditionally_skip((F.PID_P > 3.0), label="PID") + & F.conditionally_skip((F.PID_P - F.PID_K > -5), label="PID") + ), ): """ Return bnoc b-baryon soft protons. @@ -668,7 +684,7 @@ def make_detached_down_protons( ) if p_pidp_min is not None: - code = F.PID_P > p_pidp_min + code = F.conditionally_skip(F.PID_P > p_pidp_min, label="PID") protons = ParticleFilter(protons, F.FILTER(code)) return protons @@ -687,7 +703,7 @@ def make_detached_down_pions( mipchi2_min=mipchi2_min, ) if pi_pidk_max is not None: - code = F.PID_K < pi_pidk_max + code = F.conditionally_skip(F.PID_K < pi_pidk_max, label="PID") pions = ParticleFilter(pions, F.FILTER(code)) return pions @@ -701,7 +717,9 @@ def make_detached_down_pions( def make_photons(make_particles=make_photons, is_photon=0.5, et_min=150 * MeV): code = F.require_all(F.PT > et_min) if is_photon is not None: - code = F.require_all(code, F.IS_PHOTON > is_photon) + code = F.require_all( + code, F.conditionally_skip(F.IS_PHOTON > is_photon, label="IS_PHOTON") + ) return ParticleFilter(make_particles(), F.FILTER(code)) @@ -711,7 +729,11 @@ def make_soft_photons( ): """For the time being just a dummy selection""" - code = F.require_all(F.IS_PHOTON > is_photon, F.PT > et_min, F.IS_NOT_H > is_not_h) + code = F.require_all( + F.conditionally_skip(F.IS_PHOTON > is_photon, label="IS_PHOTON"), + F.PT > et_min, + F.conditionally_skip(F.IS_NOT_H > is_not_h, label="IS_NOT_H"), + ) return ParticleFilter(make_particles(is_photon=0.01), F.FILTER(code)) @@ -719,7 +741,9 @@ def make_soft_photons( def make_tight_photons( make_particles=make_photons, is_photon=None, et_min=150 * MeV, is_not_h=0.1 ): - code = F.require_all(F.PT > et_min, F.IS_NOT_H > is_not_h) + code = F.require_all( + F.PT > et_min, F.conditionally_skip(F.IS_NOT_H > is_not_h, label="IS_NOT_H") + ) return ParticleFilter(make_particles(is_photon=is_photon), F.FILTER(code)) @@ -755,7 +779,9 @@ def make_merged_pi0s(p_min=2000 * MeV, pt_min=250 * MeV, is_photon=1.0): make_particles = standard_merged_pi0 code = F.require_all(F.PT > pt_min, F.P > p_min) if is_photon is not None: - code = F.require_all(code, F.IS_PHOTON < is_photon) + code = F.require_all( + code, F.conditionally_skip(F.IS_PHOTON < is_photon, label="IS_PHOTON") + ) return ParticleFilter(make_particles(), F.FILTER(code)) @@ -776,9 +802,13 @@ def make_tight_merged_pi0s( F.MASS < am_max, ) if is_not_H is not None: - code = F.require_all(code, F.IS_NOT_H > is_not_H) + code = F.require_all( + code, F.conditionally_skip(F.IS_NOT_H > is_not_H, label="IS_NOT_H") + ) if is_photon is not None: - code = F.require_all(code, F.IS_PHOTON < is_photon) + code = F.require_all( + code, F.conditionally_skip(F.IS_PHOTON < is_photon, label="IS_PHOTON") + ) return ParticleFilter(make_particles(), F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/baryonic.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/baryonic.py index 3f5b0c303c5..5359192a0fd 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/baryonic.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/baryonic.py @@ -69,7 +69,7 @@ def _make_long_electrons_with_brem( F.P > min_p, F.PT > min_pt, F.GHOSTPROB < max_ghostprob, - F.PID_E > min_pide, + F.conditionally_skip(F.PID_E > min_pide, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=minipchi2cut, Vertices=make_pvs()), ) ), @@ -93,8 +93,8 @@ def _make_protons( F.require_all( F.P > min_p, F.PT > min_pt, - F.PID_P > min_pidp, - (F.PID_P - F.PID_K) > min_pidpk, + F.conditionally_skip(F.PID_P > min_pidp, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > min_pidpk, label="PID"), F.GHOSTPROB < max_ghostprob, F.MINIPCHI2CUT(IPChi2Cut=minipchi2cut, Vertices=make_pvs()), ) @@ -118,7 +118,7 @@ def _make_kaons( F.require_all( F.P > min_p, F.PT > min_pt, - F.PID_K > min_pidK, + F.conditionally_skip(F.PID_K > min_pidK, label="PID"), F.GHOSTPROB < max_ghostprob, F.MINIPCHI2CUT(IPChi2Cut=minipchi2cut, Vertices=make_pvs()), ) @@ -163,7 +163,10 @@ def ds2ppenu_line( F.SUM(F.PT) > pp_min_sumpt, F.require_any(F.CHILD(1, F.P) > p_min_p, F.CHILD(2, F.P) > p_min_p), F.require_any(F.CHILD(1, F.PT) > p_min_pt, F.CHILD(2, F.PT) > p_min_pt), - F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > min_prodprobnn_p, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > min_prodprobnn_p, + label="PROBNN", + ), ] combination_cuts = [ @@ -254,7 +257,10 @@ def ds2ppbar_line( F.SUM(F.PT) > comb_sum_pt_min, F.require_any(F.CHILD(1, F.P) > p_min_p, F.CHILD(2, F.P) > p_min_p), F.require_any(F.CHILD(1, F.PT) > p_min_pt, F.CHILD(2, F.PT) > p_min_pt), - F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > min_prodprobnn_p, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > min_prodprobnn_p, + label="PROBNN", + ), ] composite_cuts = [ # vertex @@ -338,7 +344,10 @@ def ds2pp_line( F.SUM(F.PT) > comb_sum_pt_min, F.require_any(F.CHILD(1, F.P) > p_min_p, F.CHILD(2, F.P) > p_min_p), F.require_any(F.CHILD(1, F.PT) > p_min_pt, F.CHILD(2, F.PT) > p_min_pt), - F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > min_prodprobnn_p, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_P) * F.CHILD(2, F.PROBNN_P) > min_prodprobnn_p, + label="PROBNN", + ), ] composite_cuts = [ # vertex @@ -420,7 +429,10 @@ def ds2kkenu_line( F.SUM(F.PT) > kk_min_sumpt, F.require_any(F.CHILD(1, F.P) > k_min_p, F.CHILD(2, F.P) > k_min_p), F.require_any(F.CHILD(1, F.PT) > k_min_pt, F.CHILD(2, F.PT) > k_min_pt), - F.CHILD(1, F.PROBNN_K) * F.CHILD(2, F.PROBNN_K) > min_prodprobnn_k, + F.conditionally_skip( + F.CHILD(1, F.PROBNN_K) * F.CHILD(2, F.PROBNN_K) > min_prodprobnn_k, + label="PROBNN", + ), ] combination_cuts = [ diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy.py index 176f159bfbb..9f3cfe17444 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy.py @@ -91,8 +91,10 @@ def _make_protons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > dllp_min, - (F.PID_P - F.PID_K) > dllp_m_dllk_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), + F.conditionally_skip( + (F.PID_P - F.PID_K) > dllp_m_dllk_min, label="PID" + ), ) ), ) @@ -113,7 +115,7 @@ def _make_kaons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ), ), ) @@ -131,7 +133,7 @@ def _make_pions_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy_mva.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy_mva.py index 992bcba95f8..93e4ee7d001 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy_mva.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_spectroscopy_mva.py @@ -93,8 +93,10 @@ def _make_protons_from_baryons_mva( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > dllp_min, - (F.PID_P - F.PID_K) > dllp_m_dllk_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), + F.conditionally_skip( + (F.PID_P - F.PID_K) > dllp_m_dllk_min, label="PID" + ), ) ), ) @@ -115,7 +117,7 @@ def _make_kaons_from_baryons_mva( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ), ), ) @@ -133,7 +135,7 @@ def _make_pions_from_baryons_mva( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_ph0_btag.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_ph0_btag.py index a9b675daca8..eaa170b32b2 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_ph0_btag.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_ph0_btag.py @@ -83,7 +83,10 @@ def _filter_long_pions(): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 250 * MeV, F.P > 2 * GeV, _MIPCHI2_MIN(6.0), F.PID_K < 5.0 + F.PT > 250 * MeV, + F.P > 2 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -94,7 +97,10 @@ def _filter_long_pions_forlambdacppimu(pt=500): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > pt * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(6.0), F.PID_K < 5.0 + F.PT > pt * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -105,7 +111,10 @@ def _filter_long_kaons(): make_has_rich_long_kaons(), F.FILTER( F.require_all( - F.PT > 300 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(6.0), F.PID_K > 5.0 + F.PT > 300 * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -119,8 +128,8 @@ def _filter_long_protons(): F.PT > 500 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(4.0), - F.PID_P > 5.0, - F.PID_P - F.PID_K > 0.0, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), ), ), ) @@ -134,7 +143,7 @@ def _filter_long_muons_loose(): F.PT > 250 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(4.0), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) @@ -148,7 +157,7 @@ def _filter_long_muons(): F.PT > 600 * MeV, F.P > 10 * GeV, _MIPCHI2_MIN(4.0), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) @@ -162,7 +171,7 @@ def _filter_tight_long_muons(): F.PT > 1 * GeV, F.P > 10 * GeV, _MIPCHI2_MIN(9.0), - F.PID_MU > 3.0, + F.conditionally_skip(F.PID_MU > 3.0, label="PID"), # trghostprob_max=None, # TODO ), ), @@ -189,8 +198,8 @@ def _filter_long_protons_from_lambda(): F.PT > 100 * MeV, F.P > 1 * GeV, _MIPCHI2_MIN(6.0), - F.PID_P > 5.0, - F.PID_P - F.PID_K > 0.0, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), ), ), ) @@ -227,7 +236,7 @@ def _filter_pions_from_etaprime(): # TODO Selections commented out for the start of Run 3 # trghostprob_max=0.4, # trchi2dof_max=3, - F.PID_K < 5, + F.conditionally_skip(F.PID_K < 5, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -297,7 +306,7 @@ def _filter_pions_from_eta_loose(): # TODO Selections commented out for the start of Run 3 # trghostprob_max=0.4, # trchi2dof_max=3, - F.PID_K < 5, + F.conditionally_skip(F.PID_K < 5, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_phh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_phh.py index 346e600b191..766da7f7dbb 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_phh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_phh.py @@ -71,7 +71,7 @@ def filter_long_pions( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -84,7 +84,7 @@ def filter_long_kaons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > pidk_min, + F.conditionally_skip(F.PID_K > pidk_min, label="PID"), ) return ParticleFilter(make_has_rich_long_kaons(), F.FILTER(cut)) @@ -101,7 +101,7 @@ def filter_long_kaons_from_strange( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > pidk_min, + F.conditionally_skip(F.PID_K > pidk_min, label="PID"), ) return ParticleFilter(make_has_rich_long_kaons(), F.FILTER(cut)) @@ -122,9 +122,9 @@ def filter_long_protons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > pidp_min, - (F.PID_P - F.PID_K > pidp_vs_k_min), - F.PROBNN_P > probb_min, + F.conditionally_skip(F.PID_P > pidp_min, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K > pidp_vs_k_min), label="PID"), + F.conditionally_skip(F.PROBNN_P > probb_min, label="PROBNN"), ) return ParticleFilter(make_has_rich_long_protons(), F.FILTER(cut)) @@ -136,8 +136,8 @@ def filter_muons_from_b( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_MU > pidmu_min, - F.ISMUON == is_muon, + F.conditionally_skip(F.PID_MU > pidmu_min, label="PID"), + F.conditionally_skip(F.ISMUON == is_muon, label="ISMUON"), ) return ParticleFilter(make_ismuon_long_muon(), F.FILTER(cut)) @@ -154,7 +154,7 @@ def filter_long_pions_from_b( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_pk.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_pk.py index c0aa8ece78e..031542944cb 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_pk.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_pk.py @@ -60,7 +60,7 @@ def filter_long_kaons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > pidk_min, + F.conditionally_skip(F.PID_K > pidk_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) @@ -79,9 +79,9 @@ def filter_long_protons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > pidp_min, - (F.PID_P - F.PID_K > dllp_min), - F.PROBNN_P > probnn_min, + F.conditionally_skip(F.PID_P > pidp_min, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K > dllp_min), label="PID"), + F.conditionally_skip(F.PROBNN_P > probnn_min, label="PROBNN"), ) return ParticleFilter(particles, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_sl.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_sl.py index ce89cc06a14..726389eb460 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_sl.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryon_to_sl.py @@ -145,7 +145,10 @@ def _filter_long_pions(): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 500 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(6.0), F.PID_K < 5.0 + F.PT > 500 * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -156,7 +159,10 @@ def _filter_long_kaons(): make_has_rich_long_kaons(), F.FILTER( F.require_all( - F.PT > 300 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(6.0), F.PID_K > 5.0 + F.PT > 300 * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -170,8 +176,8 @@ def _filter_long_protons(): F.PT > 500 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(4.0), - F.PID_P > 5.0, - F.PID_P - F.PID_K > 0.0, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), ), ), ) @@ -185,7 +191,7 @@ def _filter_long_muons_loose(): F.PT > 250 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(4.0), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) @@ -199,7 +205,7 @@ def _filter_long_muons(): F.PT > 600 * MeV, F.P > 10 * GeV, _MIPCHI2_MIN(4.0), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) @@ -213,7 +219,7 @@ def _filter_tight_long_muons(): F.PT > 1 * GeV, F.P > 10 * GeV, _MIPCHI2_MIN(9.0), - F.PID_MU > 3.0, + F.conditionally_skip(F.PID_MU > 3.0, label="PID"), # trghostprob_max=None, # TODO ), ), @@ -241,8 +247,8 @@ def _filter_long_protons_from_lambda(): F.PT > 100 * MeV, F.P > 1 * GeV, _MIPCHI2_MIN(6.0), - F.PID_P > 5.0, - F.PID_P - F.PID_K > 0.0, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), F.OWNPVIPCHI2 > 1, ), ), @@ -306,7 +312,7 @@ def _filter_long_kaons_from_omega(): F.PT > 180 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(9.0), - F.PID_K > -2.0, + F.conditionally_skip(F.PID_K > -2.0, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryonpair_spectroscopy.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryonpair_spectroscopy.py index 640baef31ca..a1c29b5bc2e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryonpair_spectroscopy.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cbaryonpair_spectroscopy.py @@ -1,224 +1,226 @@ -############################################################################### -# (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration # -# # -# This software is distributed under the terms of the GNU General Public # -# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # -# # -# In applying this licence, CERN does not waive the privileges and immunities # -# granted to it by virtue of its status as an Intergovernmental Organization # -# or submit itself to any jurisdiction. # -############################################################################### -""" -Definition of X -> Lambda_c+ Lambda_c~-, [ X -> Lambda_c+ Lambda_c+ ]cc HLT2 lines. - -Primary physics use-case in spectroscopy studies. -Based on Charm Production Cross-section Early Measurements lines as a start point. - ----- - -Hlt2Charm_X2DiLc_PR -Upsilon(1S) -> Lambda_c+ Lambda_c~- - -Hlt2Charm_X2DiLcWS_PR -[ Upsilon(1S) -> Lambda_c+ Lambda_c+ ]cc - -TODO/Notes: - -""" - -import Functors as F -from GaudiKernel.SystemOfUnits import GeV, MeV, mm -from GaudiKernel.SystemOfUnits import picosecond as ps -from Moore.config import register_line_builder -from Moore.lines import Hlt2Line -from Moore.streams import DETECTORS -from PyConf import configurable - -# from PyConf.Algorithms import ParticleRangeFilter, TwoBodyCombiner, FourBodyCombiner -from RecoConf.algorithms_thor import ParticleCombiner, ParticleFilter -from RecoConf.reconstruction_objects import make_pvs -from RecoConf.standard_particles import ( - make_has_rich_long_kaons, - make_has_rich_long_pions, - make_has_rich_long_protons, -) - -from Hlt2Conf.lines.charm.prefilters import charm_prefilters - -all_lines = {} - - -@configurable -def _make_protons_from_baryons( - pt_min=500 * MeV, p_min=10 * GeV, mipchi2_min=4.0, dllp_min=5.0, dllp_m_dllk_min=3.0 -): - pvs = make_pvs() - return ParticleFilter( - make_has_rich_long_protons(), - F.FILTER( - F.require_all( - F.PT > pt_min, - F.P > p_min, - F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > dllp_min, - (F.PID_P - F.PID_K) > dllp_m_dllk_min, - ) - ), - ) - - -@configurable -def _make_kaons_from_baryons( - pt_min=300 * MeV, - p_min=3.6 * GeV, - mipchi2_min=5.0, - dllk_min=5.0, -): - pvs = make_pvs() - return ParticleFilter( - make_has_rich_long_kaons(), - F.FILTER( - F.require_all( - F.PT > pt_min, - F.P > p_min, - F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, - ), - ), - ) - - -@configurable -def _make_pions_from_baryons( - pt_min=200 * MeV, p_min=1 * GeV, mipchi2_min=6.0, dllk_max=-0.5 -): - pvs = make_pvs() - return ParticleFilter( - make_has_rich_long_pions(), - F.FILTER( - F.require_all( - F.PT > pt_min, - F.P > p_min, - F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < dllk_max, - ), - ), - ) - - -@configurable -def _make_lcp_pKpi( - sum_pt_min=2.5 * GeV, - maxtree_pt_min=0.8 * GeV, - mipchi2_min_at_least_one=16.0, - mipchi2_min_at_least_two=9.0, - mintree_pt_min=200.0 * MeV, - mintree_mipchi2_min=4.0, - maxtree_mipchi2_min=16.0, - doca_max=0.1 * mm, - # bpvvdrho_min=0.01 * mm, - # bpvvdrho_max=10 * mm, - # bpvdira_min=0.9998, - vxchi2ndof_max=9, - bpvltime_min=0.2 * ps, - bpvfdchi2_min=24, - pt_min=2.0 * GeV, - # - comb_m_min=2_201 * MeV, - comb_m_max=2_372 * MeV, - m_min=2_211 * MeV, - m_max=2_362 * MeV, -): - pvs = make_pvs() - return ParticleCombiner( - Inputs=[ - _make_protons_from_baryons(), - _make_kaons_from_baryons(), - _make_pions_from_baryons(), - ], - DecayDescriptor="[Lambda_c+ -> p+ K- pi+]cc", - name="Charm_LcpToPpKmPip", - CombinationCut=F.require_all( - F.math.in_range(comb_m_min, F.MASS, comb_m_max), - F.SUM(F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min_at_least_one, Vertices=pvs)) - >= 1, - F.SUM(F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min_at_least_two, Vertices=pvs)) - >= 2, - F.SUM(F.PT) > sum_pt_min, - F.MAX(F.PT) > maxtree_pt_min, - F.MIN(F.PT) > mintree_pt_min, - F.MIN(F.MINIPCHI2(pvs)) > mintree_mipchi2_min, - F.MAX(F.MINIPCHI2(pvs)) > maxtree_mipchi2_min, - F.MAXSDOCACUT(doca_max), - ), - CompositeCut=F.require_all( - F.PT > pt_min, - F.math.in_range(m_min, F.MASS, m_max), - F.CHI2DOF < vxchi2ndof_max, - # F.math.in_range(bpvvdrho_min, F.OWNPVVDRHO, bpvvdrho_max), - # F.OWNPVDIRA > bpvdira_min, - # F.OWNPVLTIME > bpvltime_min, - F.OWNPVFDCHI2 > bpvfdchi2_min, - ), - ) - - -@configurable -def _make_upsilon(): - return ParticleCombiner( - name="Charm_XToLcpLcm_PR", - Inputs=[ - _make_lcp_pKpi(), - _make_lcp_pKpi(), - ], - DecayDescriptor="Upsilon(1S) -> Lambda_c+ Lambda_c~-", - ParticleCombiner="ParticleVertexFitter", - CompositeCut=F.require_all(F.CHI2DOF < 25), - PrimaryVertices=make_pvs(), - ) - - -@configurable -def _make_upsilonWS(): - return ParticleCombiner( - name="Charm_XToLcpLcm_WS_PR", - Inputs=[ - _make_lcp_pKpi(), - _make_lcp_pKpi(), - ], - DecayDescriptor="[ Upsilon(1S) -> Lambda_c+ Lambda_c+ ]cc", - ParticleCombiner="ParticleVertexFitter", - CompositeCut=F.require_all(F.CHI2DOF < 25), - PrimaryVertices=make_pvs(), - ) - - -## Baryon MVA lines - - -@register_line_builder(all_lines) -@configurable -def hlt2_charm_diLc_line(name="Hlt2Charm_Upsilon1SToLcpLcm_PR", prescale=1): - upsilon_combiner = _make_upsilon() - - return Hlt2Line( - name=name, - stream="charmlow", - algs=charm_prefilters() + [upsilon_combiner], - prescale=prescale, - raw_banks=DETECTORS, - ) - - -@register_line_builder(all_lines) -@configurable -def hlt2_charm_diLcws_line(name="Hlt2Charm_Upsilon1SToLcpLcm_WS_PR", prescale=1): - upsilonWS_combiner = _make_upsilonWS() - - return Hlt2Line( - name=name, - stream="charmlow", - algs=charm_prefilters() + [upsilonWS_combiner], - prescale=prescale, - raw_banks=DETECTORS, - ) +############################################################################### +# (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### +""" +Definition of X -> Lambda_c+ Lambda_c~-, [ X -> Lambda_c+ Lambda_c+ ]cc HLT2 lines. + +Primary physics use-case in spectroscopy studies. +Based on Charm Production Cross-section Early Measurements lines as a start point. + +---- + +Hlt2Charm_X2DiLc_PR +Upsilon(1S) -> Lambda_c+ Lambda_c~- + +Hlt2Charm_X2DiLcWS_PR +[ Upsilon(1S) -> Lambda_c+ Lambda_c+ ]cc + +TODO/Notes: + +""" + +import Functors as F +from GaudiKernel.SystemOfUnits import GeV, MeV, mm +from GaudiKernel.SystemOfUnits import picosecond as ps +from Moore.config import register_line_builder +from Moore.lines import Hlt2Line +from Moore.streams import DETECTORS +from PyConf import configurable + +# from PyConf.Algorithms import ParticleRangeFilter, TwoBodyCombiner, FourBodyCombiner +from RecoConf.algorithms_thor import ParticleCombiner, ParticleFilter +from RecoConf.reconstruction_objects import make_pvs +from RecoConf.standard_particles import ( + make_has_rich_long_kaons, + make_has_rich_long_pions, + make_has_rich_long_protons, +) + +from Hlt2Conf.lines.charm.prefilters import charm_prefilters + +all_lines = {} + + +@configurable +def _make_protons_from_baryons( + pt_min=500 * MeV, p_min=10 * GeV, mipchi2_min=4.0, dllp_min=5.0, dllp_m_dllk_min=3.0 +): + pvs = make_pvs() + return ParticleFilter( + make_has_rich_long_protons(), + F.FILTER( + F.require_all( + F.PT > pt_min, + F.P > p_min, + F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), + F.conditionally_skip( + (F.PID_P - F.PID_K) > dllp_m_dllk_min, label="PID" + ), + ) + ), + ) + + +@configurable +def _make_kaons_from_baryons( + pt_min=300 * MeV, + p_min=3.6 * GeV, + mipchi2_min=5.0, + dllk_min=5.0, +): + pvs = make_pvs() + return ParticleFilter( + make_has_rich_long_kaons(), + F.FILTER( + F.require_all( + F.PT > pt_min, + F.P > p_min, + F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), + ), + ), + ) + + +@configurable +def _make_pions_from_baryons( + pt_min=200 * MeV, p_min=1 * GeV, mipchi2_min=6.0, dllk_max=-0.5 +): + pvs = make_pvs() + return ParticleFilter( + make_has_rich_long_pions(), + F.FILTER( + F.require_all( + F.PT > pt_min, + F.P > p_min, + F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), + ), + ), + ) + + +@configurable +def _make_lcp_pKpi( + sum_pt_min=2.5 * GeV, + maxtree_pt_min=0.8 * GeV, + mipchi2_min_at_least_one=16.0, + mipchi2_min_at_least_two=9.0, + mintree_pt_min=200.0 * MeV, + mintree_mipchi2_min=4.0, + maxtree_mipchi2_min=16.0, + doca_max=0.1 * mm, + # bpvvdrho_min=0.01 * mm, + # bpvvdrho_max=10 * mm, + # bpvdira_min=0.9998, + vxchi2ndof_max=9, + bpvltime_min=0.2 * ps, + bpvfdchi2_min=24, + pt_min=2.0 * GeV, + # + comb_m_min=2_201 * MeV, + comb_m_max=2_372 * MeV, + m_min=2_211 * MeV, + m_max=2_362 * MeV, +): + pvs = make_pvs() + return ParticleCombiner( + Inputs=[ + _make_protons_from_baryons(), + _make_kaons_from_baryons(), + _make_pions_from_baryons(), + ], + DecayDescriptor="[Lambda_c+ -> p+ K- pi+]cc", + name="Charm_LcpToPpKmPip", + CombinationCut=F.require_all( + F.math.in_range(comb_m_min, F.MASS, comb_m_max), + F.SUM(F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min_at_least_one, Vertices=pvs)) + >= 1, + F.SUM(F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min_at_least_two, Vertices=pvs)) + >= 2, + F.SUM(F.PT) > sum_pt_min, + F.MAX(F.PT) > maxtree_pt_min, + F.MIN(F.PT) > mintree_pt_min, + F.MIN(F.MINIPCHI2(pvs)) > mintree_mipchi2_min, + F.MAX(F.MINIPCHI2(pvs)) > maxtree_mipchi2_min, + F.MAXSDOCACUT(doca_max), + ), + CompositeCut=F.require_all( + F.PT > pt_min, + F.math.in_range(m_min, F.MASS, m_max), + F.CHI2DOF < vxchi2ndof_max, + # F.math.in_range(bpvvdrho_min, F.OWNPVVDRHO, bpvvdrho_max), + # F.OWNPVDIRA > bpvdira_min, + # F.OWNPVLTIME > bpvltime_min, + F.OWNPVFDCHI2 > bpvfdchi2_min, + ), + ) + + +@configurable +def _make_upsilon(): + return ParticleCombiner( + name="Charm_XToLcpLcm_PR", + Inputs=[ + _make_lcp_pKpi(), + _make_lcp_pKpi(), + ], + DecayDescriptor="Upsilon(1S) -> Lambda_c+ Lambda_c~-", + ParticleCombiner="ParticleVertexFitter", + CompositeCut=F.require_all(F.CHI2DOF < 25), + PrimaryVertices=make_pvs(), + ) + + +@configurable +def _make_upsilonWS(): + return ParticleCombiner( + name="Charm_XToLcpLcm_WS_PR", + Inputs=[ + _make_lcp_pKpi(), + _make_lcp_pKpi(), + ], + DecayDescriptor="[ Upsilon(1S) -> Lambda_c+ Lambda_c+ ]cc", + ParticleCombiner="ParticleVertexFitter", + CompositeCut=F.require_all(F.CHI2DOF < 25), + PrimaryVertices=make_pvs(), + ) + + +## Baryon MVA lines + + +@register_line_builder(all_lines) +@configurable +def hlt2_charm_diLc_line(name="Hlt2Charm_Upsilon1SToLcpLcm_PR", prescale=1): + upsilon_combiner = _make_upsilon() + + return Hlt2Line( + name=name, + stream="charmlow", + algs=charm_prefilters() + [upsilon_combiner], + prescale=prescale, + raw_banks=DETECTORS, + ) + + +@register_line_builder(all_lines) +@configurable +def hlt2_charm_diLcws_line(name="Hlt2Charm_Upsilon1SToLcpLcm_WS_PR", prescale=1): + upsilonWS_combiner = _make_upsilonWS() + + return Hlt2Line( + name=name, + stream="charmlow", + algs=charm_prefilters() + [upsilonWS_combiner], + prescale=prescale, + raw_banks=DETECTORS, + ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_hadronic.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_hadronic.py index 39740fe3b86..6791243ee67 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_hadronic.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_hadronic.py @@ -167,12 +167,14 @@ def _make_protons( F.P > p_min, F.PT > pt_min, F.MINIPCHI2(pvs) > ipchi2_min, - F.PID_P > dllpi_min, - F.PROBNN_P > probnn_p_min, - F.PROBNN_GHOST < probnn_ghost_max, + F.conditionally_skip(F.PID_P > dllpi_min, label="PID"), + F.conditionally_skip(F.PROBNN_P > probnn_p_min, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < probnn_ghost_max, label="PROBNN"), ) if dllk_min is not None: - cut = F.require_all(cut, F.PID_P - F.PID_K > dllk_min) + cut = F.require_all( + cut, F.conditionally_skip(F.PID_P - F.PID_K > dllk_min, label="PID") + ) return ParticleFilter(protons, F.FILTER(cut)) @@ -195,9 +197,9 @@ def _make_kaons( F.P > p_min, F.PT > pt_min, F.MINIPCHI2(pvs) > ipchi2_min, - F.PID_K > dllpi_min, - F.PROBNN_K > probnn_k_min, - F.PROBNN_GHOST < probnn_ghost_max, + F.conditionally_skip(F.PID_K > dllpi_min, label="PID"), + F.conditionally_skip(F.PROBNN_K > probnn_k_min, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < probnn_ghost_max, label="PROBNN"), ) return ParticleFilter(kaons, F.FILTER(cut)) @@ -221,9 +223,9 @@ def _make_pions( F.P > p_min, F.PT > pt_min, F.MINIPCHI2(pvs) > ipchi2_min, - F.PID_K < -1 * dllk_min, - F.PROBNN_PI > probnn_pi_min, - F.PROBNN_GHOST < probnn_ghost_max, + F.conditionally_skip(F.PID_K < -1 * dllk_min, label="PID"), + F.conditionally_skip(F.PROBNN_PI > probnn_pi_min, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < probnn_ghost_max, label="PROBNN"), ) return ParticleFilter(pions, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_cbaryon_sl.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_cbaryon_sl.py index a60d847dbe3..9a3583d17fa 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_cbaryon_sl.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_cbaryon_sl.py @@ -64,7 +64,7 @@ def filter_long_pions(): F.PT > 180 * MeV, F.P > 2 * GeV, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -78,7 +78,7 @@ def filter_long_kaons(): F.PT > 250 * MeV, F.P > 3 * GeV, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -92,8 +92,8 @@ def filter_long_protons(): F.PT > 400 * MeV, F.P > 9 * GeV, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_P > 5.0, - F.PID_P - F.PID_K > 0.0, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), ), ), ) @@ -107,7 +107,7 @@ def filter_long_muons(): F.PT > 1000 * MeV, F.P > 6 * GeV, F.MINIPCHI2CUT(IPChi2Cut=2.0, Vertices=make_pvs()), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_hyperon_dh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_hyperon_dh.py index b0c0f0dee03..6ac0b437435 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_hyperon_dh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/ccbaryon_to_hyperon_dh.py @@ -65,7 +65,7 @@ def filter_long_pions(mipchi2_min=None): cut = F.require_all( F.PT > 100 * MeV, F.P > 1 * GeV, - F.PROBNN_PI > 0.01, + F.conditionally_skip(F.PROBNN_PI > 0.01, label="PROBNN"), ) if isinstance(mipchi2_min, (float, int)): cut &= F.OWNPVIPCHI2 > mipchi2_min @@ -79,7 +79,7 @@ def filter_long_kaons(mipchi2_min=None): cut = F.require_all( F.PT > 100 * MeV, F.P > 1 * GeV, - F.PROBNN_K > 0.01, + F.conditionally_skip(F.PROBNN_K > 0.01, label="PROBNN"), ) if isinstance(mipchi2_min, (float, int)): cut &= F.OWNPVIPCHI2 > mipchi2_min diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/charm_to_h0x.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/charm_to_h0x.py index cc8924de46e..01e8631bfa9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/charm_to_h0x.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/charm_to_h0x.py @@ -88,7 +88,7 @@ def filter_pions( F.PT > pt_min, F.P > p_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) @@ -106,7 +106,7 @@ def filter_kaons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) @@ -125,8 +125,8 @@ def filter_protons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_P > dllp_min, - F.PID_P - F.PID_K > dllpK_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > dllpK_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) @@ -165,7 +165,7 @@ def make_dielectron_with_brem( particles = electron_maker() code_e = F.require_all( - F.PID_E > PIDe_min, + F.conditionally_skip(F.PID_E > PIDe_min, label="PID"), F.PT > pt_e, F.MINIPCHI2(pvs) > minipchi2, # F.GHOSTPROB < trghostprob, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cmeson_to_sl_btag.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cmeson_to_sl_btag.py index d3baf38d0a9..b13ba261be6 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cmeson_to_sl_btag.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/cmeson_to_sl_btag.py @@ -91,7 +91,10 @@ def _filter_long_pions(): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 500 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(8.0), F.PID_K < 5.0 + F.PT > 500 * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(8.0), + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -102,7 +105,10 @@ def _filter_long_kaons(): make_has_rich_long_kaons(), F.FILTER( F.require_all( - F.PT > 350 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(8.0), F.PID_K > 5.0 + F.PT > 350 * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(8.0), + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -116,7 +122,7 @@ def _filter_long_muons_loose(): F.PT > 250 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(8.0), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) @@ -130,7 +136,7 @@ def _filter_long_muons(): F.PT > 600 * MeV, F.P > 10 * GeV, _MIPCHI2_MIN(8.0), - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) @@ -144,7 +150,7 @@ def _filter_tight_long_muons(): F.PT > 1 * GeV, F.P > 10 * GeV, _MIPCHI2_MIN(9.0), - F.PID_MU > 3.0, + F.conditionally_skip(F.PID_MU > 3.0, label="PID"), # trghostprob_max=None, # TODO ), ), @@ -159,7 +165,7 @@ def _filter_pions_from_eta_loose(): # TODO Selections commented out for the start of Run 3 # trghostprob_max=0.4, # trchi2dof_max=3, - F.PID_K < 5, + F.conditionally_skip(F.PID_K < 5, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_etax.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_etax.py index 6741bd3d1b4..6eb77e94358 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_etax.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_etax.py @@ -88,7 +88,7 @@ def _filter_pions_from_d0s(): F.PT > 250 * MeV, F.P > 3 * GeV, F.MINIPCHI2CUT(make_pvs(), 4), - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -99,7 +99,7 @@ def _filter_kaons_from_d0s(): F.PT > 250 * MeV, F.P > 3 * GeV, F.MINIPCHI2CUT(make_pvs(), 4), - F.PID_K > 5, + F.conditionally_skip(F.PID_K > 5, label="PID"), ) return ParticleFilter(make_has_rich_long_kaons(), F.FILTER(cut)) @@ -110,7 +110,7 @@ def _filter_pions_from_etas(): F.PT > 200 * MeV, F.P > 2.5 * GeV, F.MINIPCHI2CUT(make_pvs(), 4), - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hh.py index f9430108b8a..fa46737b5b4 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hh.py @@ -105,7 +105,7 @@ def make_charm_pions(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -120,7 +120,7 @@ def make_charm_kaons(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -135,7 +135,7 @@ def make_charm_pions_lowbias(): F.MINIPCUT(IPCut=60 * um, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -150,7 +150,7 @@ def make_charm_kaons_lowbias(): F.MINIPCUT(IPCut=60 * um, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -465,7 +465,7 @@ def make_charm_pions_for_b(): F.FILTER( F.require_all( F.MINIPCHI2CUT(IPChi2Cut=20.0, Vertices=make_pvs()), - F.PID_K < 0.0, + F.conditionally_skip(F.PID_K < 0.0, label="PID"), F.PT > 400 * MeV, F.P > 4 * GeV, ), @@ -479,7 +479,7 @@ def make_charm_kaons_for_b(): F.FILTER( F.require_all( F.MINIPCHI2CUT(IPChi2Cut=20.0, Vertices=make_pvs()), - F.PID_K > 2.0, + F.conditionally_skip(F.PID_K > 2.0, label="PID"), F.PT > 400 * MeV, F.P > 4 * GeV, ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhgamma.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhgamma.py index a2068536a72..c36fd2764da 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhgamma.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhgamma.py @@ -78,7 +78,7 @@ def _make_charm_pions(min_p=0 * GeV, min_pt=500 * MeV, min_ipchi2=3.0, max_pidk= F.P > min_p, F.PT > min_pt, F.MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=make_pvs()), - F.PID_K < max_pidk, + F.conditionally_skip(F.PID_K < max_pidk, label="PID"), ) ), ) @@ -92,7 +92,7 @@ def _make_charm_kaons(min_p=0 * GeV, min_pt=500 * MeV, min_ipchi2=3.0, min_pidk= F.P > min_p, F.PT > min_pt, F.MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=make_pvs()), - F.PID_K > min_pidk, + F.conditionally_skip(F.PID_K > min_pidk, label="PID"), ) ), ) @@ -122,7 +122,7 @@ def make_charm_converted_photon_eeLL( ): code_e = F.require_all(F.PT > pt_e_min, F.P > p_e_min) if pid_e_min: - code_e &= F.PID_E > pid_e_min + code_e &= F.conditionally_skip(F.PID_E > pid_e_min, label="PID") electrons = ParticleFilter( make_long_electrons_no_brem(), F.FILTER(code_e), name=name + "_electrons" ) @@ -141,7 +141,8 @@ def make_charm_converted_photon_eeLL( ) if max_pid_e_min: code_dielectron &= F.require_any( - F.CHILD(1, F.PID_E) > max_pid_e_min, F.CHILD(2, F.PID_E) > max_pid_e_min + F.conditionally_skip(F.CHILD(1, F.PID_E) > max_pid_e_min, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_E) > max_pid_e_min, label="PID"), ) return ParticleFilter(dielectron_with_brem, F.FILTER(code_dielectron), name=name) @@ -160,7 +161,7 @@ def make_charm_converted_photon_eeDD( ): code_e = F.require_all(F.PT > pt_e_min, F.P > p_e_min) if pid_e_min: - code_e &= F.PID_E > pid_e_min + code_e &= F.conditionally_skip(F.PID_E > pid_e_min, label="PID") electrons = ParticleFilter( make_down_electrons_no_brem(), F.FILTER(code_e), name=name + "_electrons" ) @@ -179,7 +180,8 @@ def make_charm_converted_photon_eeDD( ) if max_pid_e_min: code_dielectron &= F.require_any( - F.CHILD(1, F.PID_E) > max_pid_e_min, F.CHILD(2, F.PID_E) > max_pid_e_min + F.conditionally_skip(F.CHILD(1, F.PID_E) > max_pid_e_min, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_E) > max_pid_e_min, label="PID"), ) return ParticleFilter(dielectron_with_brem, F.FILTER(code_dielectron), name=name) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhhh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhhh.py index 024c71e537e..736141fe6ed 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhhh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhhh.py @@ -60,7 +60,7 @@ def make_charm_pions(): # p_min=5 * GeV, # trchi2dof_max=4, # trg_ghost_prob_max=0.5, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -77,7 +77,7 @@ def make_charm_kaons(): # p_min=5 * GeV, # trchi2dof_max=4, # trg_ghost_prob_max=0.5, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -91,7 +91,7 @@ def make_charm_pions_for_b(): F.FILTER( F.require_all( F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), - F.PID_K < 0.0, + F.conditionally_skip(F.PID_K < 0.0, label="PID"), F.PT > 200 * MeV, F.P > 2 * GeV, ), @@ -105,7 +105,7 @@ def make_charm_kaons_for_b(): F.FILTER( F.require_all( F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), - F.PID_K > 0.0, + F.conditionally_skip(F.PID_K > 0.0, label="PID"), F.PT > 200 * MeV, F.P > 2 * GeV, ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhpi0.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhpi0.py index a19d2f171ff..93082c3bdb7 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhpi0.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hhpi0.py @@ -75,7 +75,7 @@ def _make_charm_pions(): F.FILTER( F.require_all( F.PT > 500 * MeV, - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=3.0, Vertices=make_pvs()), F.GHOSTPROB < 0.35, ) @@ -89,7 +89,7 @@ def _make_charm_kaons(): F.FILTER( F.require_all( F.PT > 500 * MeV, - F.PID_K > 7, + F.conditionally_skip(F.PID_K > 7, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=3.0, Vertices=make_pvs()), F.GHOSTPROB < 0.35, ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hlnux.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hlnux.py index 624c228f159..e6eec30e1e8 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hlnux.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_hlnux.py @@ -100,8 +100,8 @@ def _make_long_kaons_for_sld(): F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), F.CHI2DOF < 3.0, F.GHOSTPROB < 0.35, - F.PID_K > 5, - F.PID_K - F.PID_MU > 5, + F.conditionally_skip(F.PID_K > 5, label="PID"), + F.conditionally_skip(F.PID_K - F.PID_MU > 5, label="PID"), ) ), ) @@ -120,7 +120,7 @@ def _make_long_pions_for_sld(): F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), F.CHI2DOF < 3.0, F.GHOSTPROB < 0.35, - F.PID_K < -5, + F.conditionally_skip(F.PID_K < -5, label="PID"), ) ), ) @@ -139,7 +139,7 @@ def _make_long_muons_for_sld(): F.PT > 500.0 * MeV, F.CHI2DOF < 3.0, F.GHOSTPROB < 0.35, - F.PID_MU > 3, + F.conditionally_skip(F.PID_MU > 3, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), ) ), @@ -161,7 +161,7 @@ def _make_long_electrons_with_brem_for_sld(): F.PT > 500.0 * MeV, F.CHI2DOF < 3.0, F.GHOSTPROB < 0.35, - F.PID_E > 1.0, + F.conditionally_skip(F.PID_E > 1.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), ) ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kshh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kshh.py index 867d0cde36c..ac8b1a0366a 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kshh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kshh.py @@ -162,7 +162,7 @@ def make_charm_kaons(): F.PT > 200.0 * MeV, F.P > 1.0 * GeV, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -179,7 +179,7 @@ def make_charm_pions(): F.PT > 200.0 * MeV, F.P > 1.0 * GeV, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -196,7 +196,7 @@ def make_charm_kaons_lowbias(): F.PT > 500 * MeV, F.P > 5 * GeV, F.MINIPCUT(IPCut=60 * um, Vertices=make_pvs()), - F.PID_K > 0.0, + F.conditionally_skip(F.PID_K > 0.0, label="PID"), ), ), ) @@ -213,7 +213,7 @@ def make_charm_pions_lowbias(): F.PT > 400 * MeV, F.P > 1500 * MeV, F.MINIPCUT(IPCut=60 * um, Vertices=make_pvs()), - F.PID_K < 0.0, + F.conditionally_skip(F.PID_K < 0.0, label="PID"), ), ), ) @@ -240,7 +240,7 @@ def make_long_pions_from_ks_lowbias(): F.FILTER( F.require_all( F.MINIPCUT(IPCut=200.0 * um, Vertices=make_pvs()), - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.PT > 200 * MeV, F.P > 1500 * MeV, ), @@ -273,7 +273,7 @@ def make_long_pions_from_ks(): F.FILTER( F.require_all( F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -289,7 +289,7 @@ def make_down_pions_from_ks(): F.require_all( F.PT > 175.0 * MeV, F.P > 3.0 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kstmunu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kstmunu.py index 3388d7c77e3..ea590bc4688 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kstmunu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d0_to_kstmunu.py @@ -89,7 +89,7 @@ def muons_for_charm(): F.PT > 300.0 * MeV, F.CHI2DOF < 3.0, F.GHOSTPROB < 0.35, - F.PID_MU > -3, + F.conditionally_skip(F.PID_MU > -3, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), ) ), @@ -102,7 +102,10 @@ def _make_pion_from_Kstar(): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 200 * MeV, F.P > 2500 * MeV, F.CHI2DOF < 3.0, F.PID_K < 5.0 + F.PT > 200 * MeV, + F.P > 2500 * MeV, + F.CHI2DOF < 3.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) ), ) @@ -118,7 +121,7 @@ def _make_long_pions(): F.PT > 200 * MeV, F.P > 2500 * MeV, F.CHI2DOF < 3.0, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) ), ) @@ -130,7 +133,10 @@ def _make_down_pions(): make_has_rich_down_pions(), F.FILTER( F.require_all( - F.PT > 200 * MeV, F.P > 2500 * MeV, F.CHI2DOF < 3.0, F.PID_K < 5.0 + F.PT > 200 * MeV, + F.P > 2500 * MeV, + F.CHI2DOF < 3.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_etah.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_etah.py index 3f9f737574e..c25ddff9db5 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_etah.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_etah.py @@ -96,7 +96,7 @@ def _filter_pions_from_eta(): cut = F.require_all( F.PT > 500 * MeV, F.MINIPCHI2CUT(make_pvs(), 25), - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -105,7 +105,7 @@ def _filter_pions_from_eta_loose(): cut = F.require_all( F.PT > 400 * MeV, F.MINIPCHI2CUT(make_pvs(), 25), - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -114,7 +114,7 @@ def _filter_pions_from_etaprime(): cut = F.require_all( F.PT > 500 * MeV, F.MINIPCHI2CUT(make_pvs(), 25), - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -131,19 +131,23 @@ def _filter_odd_particles_from_ds(particles, ptcut=600 * MeV): def _make_odd_kaons(): kaons = _filter_odd_particles_from_ds(make_has_rich_long_kaons()) - return ParticleFilter(kaons, F.FILTER(F.PID_K > 5)) + return ParticleFilter( + kaons, F.FILTER(F.conditionally_skip(F.PID_K > 5, label="PID")) + ) def _make_odd_pions(): pions = _filter_odd_particles_from_ds(make_has_rich_long_pions(), ptcut=1000 * MeV) - return ParticleFilter(pions, F.FILTER(F.PID_K < 5)) + return ParticleFilter( + pions, F.FILTER(F.conditionally_skip(F.PID_K < 5, label="PID")) + ) def _filter_muons_from_ds(): cut = F.require_all( F.PT > 500 * MeV, F.MINIPCHI2CUT(make_pvs(), 25), - F.PID_MU > 0, + F.conditionally_skip(F.PID_MU > 0, label="PID"), ) return ParticleFilter(make_ismuon_long_muon(), F.FILTER(cut)) @@ -152,8 +156,8 @@ def _filter_protons_from_lambdas(): cut = F.require_all( F.PT > 600 * MeV, F.MINIPCHI2CUT(make_pvs(), 25), - F.PID_P > 0, - F.PID_P - F.PID_K > 0, + F.conditionally_skip(F.PID_P > 0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0, label="PID"), ) return ParticleFilter(make_has_rich_long_protons(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhh.py index bef5b596619..0439d087526 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhh.py @@ -83,7 +83,7 @@ def _make_pions(): F.P > 2 * GeV, F.CHI2DOF < 99.0, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K < 5, + F.conditionally_skip(F.PID_K < 5, label="PID"), ) ), ) @@ -101,7 +101,7 @@ def _make_tight_pions(): F.P > 2 * GeV, F.CHI2DOF < 99.0, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K < 1, + F.conditionally_skip(F.PID_K < 1, label="PID"), ) ), ) @@ -119,7 +119,7 @@ def _make_kaons(): F.P > 2 * GeV, F.CHI2DOF < 99.0, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K > 5, + F.conditionally_skip(F.PID_K > 5, label="PID"), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhhgamma.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhhgamma.py index b7553dd155a..f46b320a593 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhhgamma.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_hhhgamma.py @@ -63,7 +63,7 @@ def _make_charm_pions(): F.require_all( F.PT > 300 * MeV, F.MINIPCHI2CUT(IPChi2Cut=6.0, Vertices=make_pvs()), - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), ) ), ) @@ -76,7 +76,7 @@ def _make_charm_kaons(): F.require_all( F.PT > 300 * MeV, F.MINIPCHI2CUT(IPChi2Cut=6.0, Vertices=make_pvs()), - F.PID_K > 0, + F.conditionally_skip(F.PID_K > 0, label="PID"), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksh.py index 8797c4ff5c7..31a1073d177 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksh.py @@ -61,7 +61,7 @@ def filter_long_pions( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -74,7 +74,7 @@ def filter_long_kaons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > pidk_min, + F.conditionally_skip(F.PID_K > pidk_min, label="PID"), ) return ParticleFilter(make_has_rich_long_kaons(), F.FILTER(cut)) @@ -87,14 +87,18 @@ def filter_long_pions_from_ks( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) def filter_down_pions_from_ks(pvs, pt_min=250 * MeV, p_min=2 * GeV, pion_pidk_max=15.0): """Filter downstream pions with P PT, and PIDk cuts.""" - cut = F.require_all(F.PT > pt_min, F.P > p_min, F.PID_K < pion_pidk_max) + cut = F.require_all( + F.PT > pt_min, + F.P > p_min, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), + ) return ParticleFilter(make_has_rich_down_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksksh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksksh.py index a76b0c8f409..f5e2bbc0965 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksksh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/d_to_ksksh.py @@ -62,7 +62,7 @@ def filter_long_pions( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -75,7 +75,7 @@ def filter_long_kaons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > pidk_min, + F.conditionally_skip(F.PID_K > pidk_min, label="PID"), ) return ParticleFilter(make_has_rich_long_kaons(), F.FILTER(cut)) @@ -88,14 +88,18 @@ def filter_long_pions_from_ks( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) def filter_down_pions_from_ks(pvs, pt_min=250 * MeV, p_min=2 * GeV, pion_pidk_max=15.0): """Filter downstream pions with P PT, and PIDk cuts.""" - cut = F.require_all(F.PT > pt_min, F.P > p_min, F.PID_K < pion_pidk_max) + cut = F.require_all( + F.PT > pt_min, + F.P > p_min, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), + ) return ParticleFilter(make_has_rich_down_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/detection_asymmetry_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/detection_asymmetry_lines.py index 9626dd56714..17a3015a597 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/detection_asymmetry_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/detection_asymmetry_lines.py @@ -97,7 +97,10 @@ def get_shared_detached_basic_particles( @configurable def make_pions_for_kshort(detached_particles, pvs, max_pidk=10.0, min_ipchi2=20): """These pions are used to construct KS -> pi pi candidates""" - requirements = F.require_all(F.PID_K < max_pidk, F.MINIPCHI2(pvs) > min_ipchi2) + requirements = F.require_all( + F.conditionally_skip(F.PID_K < max_pidk, label="PID"), + F.MINIPCHI2(pvs) > min_ipchi2, + ) return ParticleFilter(detached_particles, Cut=F.FILTER(requirements)) @@ -109,7 +112,11 @@ def make_probe_pions(detached_particles, max_pidk=10.0, max_eta=5.1): cuts should be as loose as possible.""" return ParticleFilter( detached_particles, - Cut=F.FILTER(F.require_all(F.PID_K < max_pidk, F.ETA < max_eta)), + Cut=F.FILTER( + F.require_all( + F.conditionally_skip(F.PID_K < max_pidk, label="PID"), F.ETA < max_eta + ) + ), ) @@ -122,7 +129,13 @@ def make_bachelor_pions( the probe pions.""" return ParticleFilter( detached_particles, - Cut=F.FILTER(F.require_all(F.PID_K < max_pidk, F.PT > pt_min, F.P > p_min)), + Cut=F.FILTER( + F.require_all( + F.conditionally_skip(F.PID_K < max_pidk, label="PID"), + F.PT > pt_min, + F.P > p_min, + ) + ), ) @@ -133,7 +146,11 @@ def make_probe_kaons(detached_particles, min_pidk=2.0, min_pt=350 * MeV): so cuts have to be as loose as possible""" return ParticleFilter( detached_particles, - Cut=F.FILTER(F.require_all(F.PID_K > min_pidk, F.PT > min_pt)), + Cut=F.FILTER( + F.require_all( + F.conditionally_skip(F.PID_K > min_pidk, label="PID"), F.PT > min_pt + ) + ), ) @@ -151,9 +168,9 @@ def make_bachelor_protons( to measure an asymmetry with, cuts can be tighter than for probe particles.""" requirements = F.require_all( - F.PID_P > min_pidp, + F.conditionally_skip(F.PID_P > min_pidp, label="PID"), F.PT > min_pt, - (F.PID_P - F.PID_K) > min_pid_p_wrt_k, + F.conditionally_skip((F.PID_P - F.PID_K) > min_pid_p_wrt_k, label="PID"), F.MINIPCHI2(pvs) > min_ipchi2, ) return ParticleFilter(detached_particles, Cut=F.FILTER(requirements)) @@ -475,7 +492,7 @@ def make_prompt_dplus_to_kpipi( F.MAXSDOCACUT(doca_max), F.MAX(F.MINIPCHI2(pvs)) > amaxchild_ipchi2_min, F.SUM(F.MINIPCHI2(pvs) > trk_2of3_ipchi2_min) > 1, - F.CHILD(1, F.PID_K > bachelor_kaon_pidk_min), + F.CHILD(1, F.conditionally_skip(F.PID_K > bachelor_kaon_pidk_min, label="PID")), ) cos_bpvdira_min = math.cos(acos_bpvdira_max) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dsstar_to_dspipi.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dsstar_to_dspipi.py index 6c8c2b2b0a7..5702bfca0f2 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dsstar_to_dspipi.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dsstar_to_dspipi.py @@ -38,7 +38,7 @@ def make_pions_from_ds_decay(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.P > 1.2 * GeV, F.PT > 245 * MeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -56,7 +56,7 @@ def make_pions_from_dsstar_decay(): # p_min=5 * GeV, # trchi2dof_max=4, # trg_ghost_prob_max=0.5, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -74,7 +74,7 @@ def make_kaons(): # p_min=5 * GeV, # trchi2dof_max=4, # trg_ghost_prob_max=0.5, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dst_to_dee_makers.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dst_to_dee_makers.py index 42d8e06d8b0..8e5c609363c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dst_to_dee_makers.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/dst_to_dee_makers.py @@ -48,7 +48,7 @@ def make_pions_for_d0_to_hh(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -63,7 +63,7 @@ def make_untight_pions_for_d0_to_hh(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 500 * MeV, F.P > 3 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -78,7 +78,7 @@ def make_kaons_for_d0_to_hh(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -93,7 +93,7 @@ def make_untight_kaons_for_d0_to_hh(): F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 500 * MeV, F.P > 3 * GeV, - F.PID_K > -5.0, + F.conditionally_skip(F.PID_K > -5.0, label="PID"), ), ), ) @@ -113,7 +113,7 @@ def make_pions_for_d0_to_hhhh(): # F.P > p_min, # F.CHI2DOF < trchi2dof_max, # F.GHOSTPROB < trghostprob, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -133,7 +133,7 @@ def make_untight_pions_for_d0_to_hhhh(): # TODO, # F.CHI2DOF < trchi2dof_max, # F.GHOSTPROB < trghostprob, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -153,7 +153,7 @@ def make_kaons_for_d0_to_hhhh(): # F.P > p_min, # F.CHI2DOF < trchi2dof_max, # F.GHOSTPROB < trghostprob, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -173,7 +173,7 @@ def make_untight_kaons_for_d0_to_hhhh(): # TODO, # F.CHI2DOF < trchi2dof_max, # F.GHOSTPROB < trghostprob, - F.PID_K > 0.0, + F.conditionally_skip(F.PID_K > 0.0, label="PID"), ), ), ) @@ -194,7 +194,7 @@ def make_pions_for_d_to_hhh(): # TODO, # F.GHOSTPROB < trghostprob, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -215,7 +215,7 @@ def make_untight_pions_for_d_to_hhh(): # TODO, # F.GHOSTPROB < trghostprob, F.MINIPCHI2CUT(IPChi2Cut=3.0, Vertices=make_pvs()), - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -237,7 +237,7 @@ def make_kaons_for_d_to_hhh(): # TODO # F.GHOSTPROB < trghostprob, F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -259,7 +259,7 @@ def make_untight_kaons_for_d_to_hhh(): # TODO # F.GHOSTPROB < trghostprob, F.MINIPCHI2CUT(IPChi2Cut=3.0, Vertices=make_pvs()), - F.PID_K > -5.0, + F.conditionally_skip(F.PID_K > -5.0, label="PID"), ), ), ) @@ -283,7 +283,7 @@ def make_prompt_electrons_no_brem(pt_min=0 * MeV, with_upstream=False): # TODO, # F.CHI2 < trchi2_max, F.MINIPCHI2CUT(IPChi2Cut=0.0, Vertices=make_pvs()), - F.PID_E > 0.0, + F.conditionally_skip(F.PID_E > 0.0, label="PID"), ), ), ) @@ -307,7 +307,7 @@ def make_untight_prompt_electrons_no_brem(pt_min=0 * MeV, with_upstream=False): # TODO, # F.CHI2 < trchi2_max, F.MINIPCHI2CUT(IPChi2Cut=0.0, Vertices=make_pvs()), - F.PID_E > -3.0, + F.conditionally_skip(F.PID_E > -3.0, label="PID"), ), ), ) @@ -353,8 +353,8 @@ def make_photons_to_preserve(dielectrons, coneangle=1.5): F.require_all( F.PT > 100 * MeV, F.P > 0 * MeV, - F.IS_PHOTON > 0.0, - F.IS_NOT_H > 0.2, + F.conditionally_skip(F.IS_PHOTON > 0.0, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.2, label="IS_NOT_H"), F.CALO_NEUTRAL_SHOWER_SHAPE > 0, ), ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hadronic_interaction_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hadronic_interaction_lines.py index 330fe752629..b7ab22e56ba 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hadronic_interaction_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hadronic_interaction_lines.py @@ -80,7 +80,7 @@ def _hadint_make_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 0.0, + F.conditionally_skip(F.PID_K > 0.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), ), ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hexaquarks.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hexaquarks.py index 68651b99eef..747dbabccad 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hexaquarks.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hexaquarks.py @@ -115,8 +115,8 @@ def _make_protons_detached( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PROBNN_P > probnnp_min, - F.PROBNN_K < probnnk_max, + F.conditionally_skip(F.PROBNN_P > probnnp_min, label="PROBNN"), + F.conditionally_skip(F.PROBNN_K < probnnk_max, label="PROBNN"), ) ), ) @@ -137,7 +137,7 @@ def _make_kaons_detached( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PROBNN_K > probnnk_min, + F.conditionally_skip(F.PROBNN_K > probnnk_min, label="PROBNN"), ), ), ) @@ -155,7 +155,7 @@ def _make_pions_detached( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PROBNN_PI > probnnpi_min, + F.conditionally_skip(F.PROBNN_PI > probnnpi_min, label="PROBNN"), ), ), ) @@ -1824,8 +1824,24 @@ pp_bpvipchi2_max = 1e5 def make_detached_pp_loosePt(name, descriptors): protons = _make_protons_detached() comb_cut_add = F.require_all( - F.SUM(F.PROBNN_P > probnnp_min_at_least_one) >= 1, - F.SUM(F.PROBNN_K < probnnk_max_at_least_one) >= 1, + F.conditionally_skip( + F.SUM( + F.conditionally_skip( + F.PROBNN_P > probnnp_min_at_least_one, label="PROBNN" + ) + ) + >= 1, + label="PROBNN", + ), + F.conditionally_skip( + F.SUM( + F.conditionally_skip( + F.PROBNN_K < probnnk_max_at_least_one, label="PROBNN" + ) + ) + >= 1, + label="PROBNN", + ), ) return make_combination_detached( @@ -1848,8 +1864,24 @@ def make_detached_pp_loosePt(name, descriptors): def make_detached_pp_tightPt(name, descriptors): protons = _make_protons_detached() comb_cut_add = F.require_all( - F.SUM(F.PROBNN_P > probnnp_min_at_least_one) >= 1, - F.SUM(F.PROBNN_K < probnnk_max_at_least_one) >= 1, + F.conditionally_skip( + F.SUM( + F.conditionally_skip( + F.PROBNN_P > probnnp_min_at_least_one, label="PROBNN" + ) + ) + >= 1, + label="PROBNN", + ), + F.conditionally_skip( + F.SUM( + F.conditionally_skip( + F.PROBNN_K < probnnk_max_at_least_one, label="PROBNN" + ) + ) + >= 1, + label="PROBNN", + ), ) return make_combination_detached( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperons.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperons.py index f5cd59b5e6b..9b856dd35a1 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperons.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperons.py @@ -331,7 +331,7 @@ def _make_long_pions_for_lambda(): F.PT > 80 * MeV, F.OWNPVIPCHI2 > 32.0, F.OWNPVIP > 200 * um, - F.PROBNN_PI > 0.01, + F.conditionally_skip(F.PROBNN_PI > 0.01, label="PROBNN"), ) ), ) @@ -341,7 +341,11 @@ def _make_long_pions_for_kshort(): return ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 100 * MeV, F.OWNPVIPCHI2 > 24.0, F.PROBNN_PI > 0.03) + F.require_all( + F.PT > 100 * MeV, + F.OWNPVIPCHI2 > 24.0, + F.conditionally_skip(F.PROBNN_PI > 0.03, label="PROBNN"), + ) ), ) @@ -354,7 +358,7 @@ def _make_long_pions_for_xi(): F.PT > 100 * MeV, F.OWNPVIPCHI2 > 24.0, F.OWNPVIP > 150 * um, - F.PROBNN_PI > 0.3, + F.conditionally_skip(F.PROBNN_PI > 0.3, label="PROBNN"), ) ), ) @@ -363,14 +367,24 @@ def _make_long_pions_for_xi(): def _make_down_pions_for_kshort(): return ParticleFilter( make_has_rich_down_pions(), - F.FILTER(F.require_all(F.PT > 150 * MeV, F.PROBNN_PI > 0.1)), + F.FILTER( + F.require_all( + F.PT > 150 * MeV, + F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), + ) + ), ) def _make_down_pions_for_lambda(): return ParticleFilter( make_has_rich_down_pions(), - F.FILTER(F.require_all(F.PT > 100 * MeV, F.PROBNN_PI > 0.4)), + F.FILTER( + F.require_all( + F.PT > 100 * MeV, + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + ) + ), ) @@ -378,7 +392,11 @@ def _make_long_kaons_for_omega(): return ParticleFilter( make_has_rich_long_kaons(), F.FILTER( - F.require_all(F.PT > 180 * MeV, F.OWNPVIPCHI2 > 24.0, F.PROBNN_K > 0.1) + F.require_all( + F.PT > 180 * MeV, + F.OWNPVIPCHI2 > 24.0, + F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), + ) ), ) @@ -386,7 +404,11 @@ def _make_long_kaons_for_omega(): def _make_down_kaons_for_omega(): return ParticleFilter( make_has_rich_down_kaons(), - F.FILTER(F.require_all(F.PT > 200 * MeV, F.PROBNN_K > 0.1)), + F.FILTER( + F.require_all( + F.PT > 200 * MeV, F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN") + ) + ), ) @@ -398,7 +420,7 @@ def _make_long_protons_for_lambda(): F.PT > 450 * MeV, F.OWNPVIPCHI2 > 12.0, F.OWNPVIP > 80 * um, - F.PROBNN_P > 0.01, + F.conditionally_skip(F.PROBNN_P > 0.01, label="PROBNN"), ) ), ) @@ -407,7 +429,12 @@ def _make_long_protons_for_lambda(): def _make_down_protons_for_lambda(): return ParticleFilter( make_has_rich_down_protons(), - F.FILTER(F.require_all(F.PT > 600 * MeV, F.PROBNN_P > 0.01)), + F.FILTER( + F.require_all( + F.PT > 600 * MeV, + F.conditionally_skip(F.PROBNN_P > 0.01, label="PROBNN"), + ) + ), ) @@ -524,7 +551,10 @@ def _make_dd_lambdas(): def _make_dd_lambdas_for_charm(): - return ParticleFilter(_make_dd_lambdas(), F.FILTER(F.CHILD(1, F.PROBNN_P) > 0.1)) + return ParticleFilter( + _make_dd_lambdas(), + F.FILTER(F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN")), + ) # This will always ever be called with ll_lambdas=_make_ll_lambdas_for_hyperon and _make_long_pions_for_xi. @@ -677,7 +707,11 @@ def _make_loose_pions_for_charm(): return ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 180 * MeV, F.OWNPVIPCHI2 > 2.5, F.PROBNN_PI > 0.1) + F.require_all( + F.PT > 180 * MeV, + F.OWNPVIPCHI2 > 2.5, + F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), + ) ), ) @@ -689,7 +723,11 @@ def _make_std_pions_for_charm(): return ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 280 * MeV, F.OWNPVIPCHI2 > 4.0, F.PROBNN_PI > 0.1) + F.require_all( + F.PT > 280 * MeV, + F.OWNPVIPCHI2 > 4.0, + F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), + ) ), ) @@ -701,7 +739,11 @@ def _make_tight_pions_for_charm(): return ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 400 * MeV, F.OWNPVIPCHI2 > 6.0, F.PROBNN_PI > 0.1) + F.require_all( + F.PT > 400 * MeV, + F.OWNPVIPCHI2 > 6.0, + F.conditionally_skip(F.PROBNN_PI > 0.1, label="PROBNN"), + ) ), ) @@ -713,7 +755,11 @@ def _make_verytight_pions_for_charm(): return ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 750 * MeV, F.OWNPVIPCHI2 > 9.0, F.PROBNN_PI > 0.3) + F.require_all( + F.PT > 750 * MeV, + F.OWNPVIPCHI2 > 9.0, + F.conditionally_skip(F.PROBNN_PI > 0.3, label="PROBNN"), + ) ), ) @@ -725,7 +771,11 @@ def _make_loose_kaons_for_charm(): return ParticleFilter( make_has_rich_long_kaons(), F.FILTER( - F.require_all(F.PT > 360 * MeV, F.OWNPVIPCHI2 > 3.0, F.PROBNN_K > 0.1) + F.require_all( + F.PT > 360 * MeV, + F.OWNPVIPCHI2 > 3.0, + F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), + ) ), ) @@ -737,7 +787,11 @@ def _make_std_kaons_for_charm(): return ParticleFilter( make_has_rich_long_kaons(), F.FILTER( - F.require_all(F.PT > 420 * MeV, F.OWNPVIPCHI2 > 4.0, F.PROBNN_K > 0.3) + F.require_all( + F.PT > 420 * MeV, + F.OWNPVIPCHI2 > 4.0, + F.conditionally_skip(F.PROBNN_K > 0.3, label="PROBNN"), + ) ), ) @@ -749,7 +803,11 @@ def _make_tight_kaons_for_charm(): return ParticleFilter( make_has_rich_long_kaons(), F.FILTER( - F.require_all(F.PT > 550 * MeV, F.OWNPVIPCHI2 > 6.0, F.PROBNN_K > 0.5) + F.require_all( + F.PT > 550 * MeV, + F.OWNPVIPCHI2 > 6.0, + F.conditionally_skip(F.PROBNN_K > 0.5, label="PROBNN"), + ) ), ) @@ -761,7 +819,11 @@ def _make_verytight_kaons_for_charm(): return ParticleFilter( make_has_rich_long_kaons(), F.FILTER( - F.require_all(F.PT > 750 * MeV, F.OWNPVIPCHI2 > 9.0, F.PROBNN_K > 0.8) + F.require_all( + F.PT > 750 * MeV, + F.OWNPVIPCHI2 > 9.0, + F.conditionally_skip(F.PROBNN_K > 0.8, label="PROBNN"), + ) ), ) @@ -777,8 +839,8 @@ def _make_std_sigmams_for_charm(): F.PT > 1.8 * GeV, F.P > 60 * GeV, F.OWNPVIPCHI2 > 4.0, - F.PID_P > 7.0, - F.PID_P - F.PID_K > 5.0, + F.conditionally_skip(F.PID_P > 7.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 5.0, label="PID"), ) ), ) @@ -892,13 +954,23 @@ def sp_to_pmumu_match(name="Hlt2Charm_SpToPpMumMup_VeloMatch_SP"): make_has_rich_down_protons(), F.FILTER( F.require_all( - F.PT > 350 * MeV, F.PROBNN_P * (1 - F.PROBNN_K) > 0.05, F.PROBNN_P > 0.1 + F.PT > 350 * MeV, + F.conditionally_skip( + F.PROBNN_P * (1 - F.PROBNN_K) > 0.05, label="PROBNN" + ), + F.conditionally_skip(F.PROBNN_P > 0.1, label="PROBNN"), ) ), ) muons = ParticleFilter( make_down_muons(), - F.FILTER(F.require_all(F.ISMUON, F.PT > 80 * MeV, F.PROBNN_MU > 0.2)), + F.FILTER( + F.require_all( + F.ISMUON, + F.PT > 80 * MeV, + F.conditionally_skip(F.PROBNN_MU > 0.2, label="PROBNN"), + ) + ), ) sigmaps = ParticleCombiner( [protons, muons, muons], @@ -930,7 +1002,13 @@ def sp_to_pmumu_match(name="Hlt2Charm_SpToPpMumMup_VeloMatch_SP"): def xi_to_lmu_match(name="Hlt2Charm_XimToL0MumNu_VeloMatch_SP"): muons = ParticleFilter( make_down_muons(), - F.FILTER(F.require_all(F.ISMUON, F.PT > 150 * MeV, F.PROBNN_MU > 0.4)), + F.FILTER( + F.require_all( + F.ISMUON, + F.PT > 150 * MeV, + F.conditionally_skip(F.PROBNN_MU > 0.4, label="PROBNN"), + ) + ), ) xis = ParticleCombiner( [_make_dd_lambdas(), muons], @@ -1178,8 +1256,10 @@ def xic0_to_smpip_longsm_line(name="Hlt2Charm_Xic0ToSmPip_LongSm_Inclb_SP"): F.PT > 2 * GeV, F.P > 22 * GeV, F.OWNPVIPCHI2 > 9.0, - F.PROBNN_P > 0.8, - F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.6, + F.conditionally_skip(F.PROBNN_P > 0.8, label="PROBNN"), + F.conditionally_skip( + F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.6, label="PROBNN" + ), ) ), ) @@ -1929,7 +2009,7 @@ def Lcp_to_SpPipPim_longsp_line(name="Hlt2Charm_LcpToSpPimPip_LongSp"): F.PT > 600 * MeV, F.P > 200 * GeV, F.OWNPVIPCHI2 > 9.0, - (F.PID_P - F.PID_K) > 5.0, + F.conditionally_skip((F.PID_P - F.PID_K) > 5.0, label="PID"), ), ), ) @@ -2004,8 +2084,10 @@ def _make_down_protons_for_sigma(): F.FILTER( F.require_all( F.PT > 1000 * MeV, - F.PROBNN_P * (1 - F.PROBNN_K) > 0.05, - F.PROBNN_P > 0.5, + F.conditionally_skip( + F.PROBNN_P * (1 - F.PROBNN_K) > 0.05, label="PROBNN" + ), + F.conditionally_skip(F.PROBNN_P > 0.5, label="PROBNN"), ) ), ) @@ -2102,7 +2184,7 @@ def Lcp_to_SmPipPip_longsm_line(name="Hlt2Charm_LcpToSmPipPip_LongSm"): F.PT > 100 * MeV, F.P > 100 * GeV, F.OWNPVIPCHI2 > 9.0, - (F.PID_P - F.PID_K) > 5.0, + F.conditionally_skip((F.PID_P - F.PID_K) > 5.0, label="PID"), ), ), ) @@ -2147,15 +2229,21 @@ def o_to_xipipi_line(name="Hlt2Charm_OmToXimPimPip_LongXim_SP"): F.PT > 600 * MeV, F.P > 25 * GeV, F.OWNPVIPCHI2 > 24.0, - F.PROBNN_P > 0.8, - F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.6, + F.conditionally_skip(F.PROBNN_P > 0.8, label="PROBNN"), + F.conditionally_skip( + F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.6, label="PROBNN" + ), ) ), ) pions = ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 100 * MeV, F.OWNPVIPCHI2 > 48.0, F.PROBNN_PI > 0.3) + F.require_all( + F.PT > 100 * MeV, + F.OWNPVIPCHI2 > 48.0, + F.conditionally_skip(F.PROBNN_PI > 0.3, label="PROBNN"), + ) ), ) omegas = ParticleCombiner( @@ -2303,7 +2391,11 @@ def lb0_to_lcpi_lc_to_smpipi_longsm_line( pions = ParticleFilter( make_has_rich_long_pions(), F.FILTER( - F.require_all(F.PT > 200 * MeV, F.OWNPVIPCHI2 > 9.0, F.PROBNN_PI > 0.5) + F.require_all( + F.PT > 200 * MeV, + F.OWNPVIPCHI2 > 9.0, + F.conditionally_skip(F.PROBNN_PI > 0.5, label="PROBNN"), + ) ), ) lcs = ParticleCombiner( @@ -2782,8 +2874,10 @@ def xicp_to_ximpipi_longxim_line( F.PT > 1.5 * GeV, F.P > 25 * GeV, F.OWNPVIPCHI2 > 16.0, - F.PROBNN_P > 0.75, - F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.5, + F.conditionally_skip(F.PROBNN_P > 0.75, label="PROBNN"), + F.conditionally_skip( + F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.5, label="PROBNN" + ), ) ), ) @@ -2961,8 +3055,10 @@ def xicp_to_omkpi_longom_line(name="Hlt2Charm_Xib0ToXicpPim_XicpToOmKpPip_LongOm F.PT > 1.6 * GeV, F.P > 32 * GeV, F.OWNPVIPCHI2 > 16.0, - F.PROBNN_P > 0.75, - F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.5, + F.conditionally_skip(F.PROBNN_P > 0.75, label="PROBNN"), + F.conditionally_skip( + F.PROBNN_P * (1.0 - F.PROBNN_K) > 0.5, label="PROBNN" + ), ) ), ) @@ -3080,10 +3176,10 @@ def xiczoc_to_lkpi_ll_line(name="Hlt2Charm_Xic0Oc0ToL0KmPip_LL_SP"): Combination12Cut=F.require_all( F.CHILD(1, F.PT) > 2 * GeV, F.MASS < 2675 * MeV, - F.CHILD(2, F.PROBNN_K) > 0.5, + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.5, label="PROBNN"), ), CombinationCut=F.require_all( - F.CHILD(3, F.PROBNN_PI) > 0.3, + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.3, label="PROBNN"), F.math.in_range(2260 * MeV, F.MASS, 2815 * MeV), F.require_any(F.CHILD(2, F.PT) > 750 * MeV, F.CHILD(3, F.PT) > 750 * MeV), F.require_any( @@ -3122,13 +3218,13 @@ def xiczoc_to_lkpi_dd_line(name="Hlt2Charm_Xic0Oc0ToL0KmPip_DD_SP"): ParticleCombiner=ParticleVertexFitter(MassConstraints=["Lambda0"]), Combination12Cut=F.require_all( F.CHILD(1, F.PT) > 2.4 * GeV, - F.CHILD(2, F.PROBNN_K) > 0.5, + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.5, label="PROBNN"), F.MASS < 2675 * MeV, F.MAXDOCACUT(1.5 * mm), ), CombinationCut=F.require_all( F.math.in_range(2260 * MeV, F.MASS, 2815 * MeV), - F.CHILD(3, F.PROBNN_PI) > 0.3, + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.3, label="PROBNN"), F.require_any(F.CHILD(2, F.PT) > 800 * MeV, F.CHILD(3, F.PT) > 800 * MeV), F.require_any( F.CHILD(2, F.OWNPVIPCHI2) > 16.0, F.CHILD(3, F.OWNPVIPCHI2) > 16.0 @@ -3255,8 +3351,8 @@ def xic0_to_smkspip_ll_longsm_line( F.require_any( F.CHILD(1, F.OWNPVIPCHI2) > 12.0, F.CHILD(3, F.OWNPVIPCHI2) > 12.0 ), - F.CHILD(3, F.PID_K) < 5.0, - F.CHILD(3, F.PID_P) < 0.1, + F.conditionally_skip(F.CHILD(3, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(3, F.PID_P) < 0.1, label="PID"), F.DOCA(1, 3) < 100 * um, F.DOCA(2, 3) < 250 * um, ), @@ -3301,8 +3397,8 @@ def xic0_to_smkspip_dd_longsm_line( F.require_any( F.CHILD(1, F.OWNPVIPCHI2) > 12.0, F.CHILD(3, F.OWNPVIPCHI2) > 12.0 ), - F.CHILD(3, F.PID_K) < 5.0, - F.CHILD(3, F.PID_P) < 0.1, + F.conditionally_skip(F.CHILD(3, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(3, F.PID_P) < 0.1, label="PID"), F.DOCA(1, 3) < 100 * um, F.DOCA(2, 3) < 2.5 * mm, ), @@ -3647,7 +3743,10 @@ def lc_to_l0pipipi_ll_line(name="Hlt2Charm_LcpToL0PimPipPip_LL"): make_has_rich_long_protons(), F.FILTER( F.require_all( - F.PT > 400 * MeV, F.P > 9 * GeV, F.OWNPVIPCHI2 > 6.0, F.PID_P > -5.0 + F.PT > 400 * MeV, + F.P > 9 * GeV, + F.OWNPVIPCHI2 > 6.0, + F.conditionally_skip(F.PID_P > -5.0, label="PID"), ) ), ) @@ -3678,7 +3777,10 @@ def lc_to_l0pipipi_ll_line(name="Hlt2Charm_LcpToL0PimPipPip_LL"): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 300 * MeV, F.P > 2 * GeV, F.OWNPVIPCHI2 > 5.0, F.PID_K < 5.0 + F.PT > 300 * MeV, + F.P > 2 * GeV, + F.OWNPVIPCHI2 > 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) ), ) @@ -3725,12 +3827,22 @@ def lc_to_l0pipipi_ll_line(name="Hlt2Charm_LcpToL0PimPipPip_LL"): def lc_to_l0pipipi_dd_line(name="Hlt2Charm_LcpToL0PimPipPip_DD"): protons = ParticleFilter( make_has_rich_down_protons(), - F.FILTER(F.require_all(F.PT > 500 * MeV, F.P > 9 * GeV, F.PID_P > -2.0)), + F.FILTER( + F.require_all( + F.PT > 500 * MeV, + F.P > 9 * GeV, + F.conditionally_skip(F.PID_P > -2.0, label="PID"), + ) + ), ) down_lambda_pions = ParticleFilter( make_has_rich_down_pions(), - F.FILTER(F.require_all(F.PT > 100 * MeV, F.PID_K < 5.0)), + F.FILTER( + F.require_all( + F.PT > 100 * MeV, F.conditionally_skip(F.PID_K < 5.0, label="PID") + ) + ), ) dd_lambdas = ParticleCombiner( @@ -3754,7 +3866,10 @@ def lc_to_l0pipipi_dd_line(name="Hlt2Charm_LcpToL0PimPipPip_DD"): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 300 * MeV, F.P > 2 * GeV, F.OWNPVIPCHI2 > 4.0, F.PID_K < 5.0 + F.PT > 300 * MeV, + F.P > 2 * GeV, + F.OWNPVIPCHI2 > 4.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) ), ) @@ -4208,10 +4323,10 @@ def xicp_to_smkspippip_ll_longsm_line( F.require_any( F.CHILD(3, F.OWNPVIPCHI2) > 9.0, F.CHILD(4, F.OWNPVIPCHI2) > 9.0 ), - F.CHILD(3, F.PID_K) < 5.0, - F.CHILD(3, F.PID_P) < 0.1, - F.CHILD(4, F.PID_K) < 5.0, - F.CHILD(4, F.PID_P) < 0.1, + F.conditionally_skip(F.CHILD(3, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(3, F.PID_P) < 0.1, label="PID"), + F.conditionally_skip(F.CHILD(4, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(4, F.PID_P) < 0.1, label="PID"), F.DOCA(1, 4) < 150 * um, F.DOCA(2, 4) < 300 * um, F.DOCA(3, 4) < 200 * um, @@ -4268,10 +4383,10 @@ def xicp_to_smkspippip_dd_longsm_line( F.CHILD(3, F.OWNPVIPCHI2) > 24.0, F.CHILD(4, F.OWNPVIPCHI2) > 24.0, ), - F.CHILD(3, F.PID_K) < 5.0, - F.CHILD(3, F.PID_P) < 0.1, - F.CHILD(4, F.PID_K) < 5.0, - F.CHILD(4, F.PID_P) < 0.1, + F.conditionally_skip(F.CHILD(3, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(3, F.PID_P) < 0.1, label="PID"), + F.conditionally_skip(F.CHILD(4, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(4, F.PID_P) < 0.1, label="PID"), F.DOCA(1, 4) < 150 * um, F.DOCA(2, 4) < 3 * mm, F.DOCA(3, 4) < 200 * um, @@ -4444,7 +4559,11 @@ def xicz_to_smkmpippip_longsm_line( sigmams = ParticleFilter( _make_std_sigmams_for_charm(), F.FILTER( - F.require_all(F.P > 60 * GeV, F.PID_P > 10.0, F.PID_P - F.PID_K > 7.0) + F.require_all( + F.P > 60 * GeV, + F.conditionally_skip(F.PID_P > 10.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 7.0, label="PID"), + ) ), ) xics = ParticleCombiner( @@ -4459,7 +4578,7 @@ def xicz_to_smkmpippip_longsm_line( Combination12Cut=F.require_all( F.MASS < 2310 * MeV, F.MAX(F.OWNPVIPCHI2) > 12.0, - F.CHILD(2, F.PID_K - F.PID_P > -0.01), + F.CHILD(2, F.conditionally_skip(F.PID_K - F.PID_P > -0.01, label="PID")), ), Combination123Cut=F.require_all( F.MASS < 2450 * MeV, F.MAX(F.OWNPVIPCHI2) > 24.0 @@ -4468,8 +4587,8 @@ def xicz_to_smkmpippip_longsm_line( F.math.in_range(2350 * MeV, F.MASS, 2590 * MeV), F.PT > 2.9 * GeV, F.MAX(F.OWNPVIPCHI2) > 64.0, - F.CHILD(3, F.PID_K) < 5.0, - F.CHILD(4, F.PID_K) < 5.0, + F.conditionally_skip(F.CHILD(3, F.PID_K) < 5.0, label="PID"), + F.conditionally_skip(F.CHILD(4, F.PID_K) < 5.0, label="PID"), F.MAXSDOCACUT(250 * um), ), CompositeCut=F.require_all( @@ -5039,7 +5158,7 @@ def _make_xic_to_pipixi(): DecayDescriptor="[Xi_c+ -> pi+ pi+ Xi-]cc", name="Charm_Hyperons_XicpToPipPipXim_V_{hash}", Combination12Cut=F.require_all( - F.MIN(F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.MIN(F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAX(F.PT) > 560 * MeV, F.MIN(F.OWNPVIPCHI2) > 9.0, F.MAX(F.OWNPVIPCHI2) > 48.0, @@ -5069,7 +5188,7 @@ def _make_xic_to_pixi(): DecayDescriptor="[Xi_c0 -> pi+ Xi-]cc", name="Charm_Hyperons_Xic0ToPipXim_V_{hash}", CombinationCut=F.require_all( - F.CHILD(1, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_PI) > 0.5, label="PROBNN"), F.CHILD(1, F.OWNPVIPCHI2) > 24.0, F.CHILD(1, F.PT) > 600 * MeV, F.MAXSDOCACUT(120 * um), @@ -5093,7 +5212,7 @@ def _make_oc_to_pio(): DecayDescriptor="[Omega_c0 -> pi+ Omega-]cc", name="Charm_Hyperons_Oc0ToPipOm_V_{hash}", CombinationCut=F.require_all( - F.CHILD(1, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_PI) > 0.5, label="PROBNN"), F.CHILD(1, F.OWNPVIPCHI2) > 24.0, F.CHILD(1, F.PT) > 550 * MeV, F.MAXSDOCACUT(120 * um), @@ -5120,7 +5239,7 @@ def _make_b_to_pic(cb, descriptor): name="Charm_Hyperons_BeautyToPimCharm_V_{hash}", CombinationCut=F.require_all( F.CHILD(1, F.OWNPVIPCHI2) > 36.0, - F.CHILD(1, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_PI) > 0.5, label="PROBNN"), F.CHILD(1, F.PT) > 650 * MeV, F.MAXSDOCACUT(120 * um), ), @@ -5225,11 +5344,21 @@ def _filter_clones_of_light_hadrons(particles): ) light_long_hadrons = ParticleFilter( make_has_rich_long_pions(), - F.FILTER(F.require_any(F.PID_P - F.PID_K < 1.0, F.PID_P < 3.0)), + F.FILTER( + F.require_any( + F.conditionally_skip(F.PID_P - F.PID_K < 1.0, label="PID"), + F.conditionally_skip(F.PID_P < 3.0, label="PID"), + ) + ), ) light_upstream_hadrons = ParticleFilter( make_has_rich_up_pions(), - F.FILTER(F.require_any(F.PID_P - F.PID_K < 1.0, F.PID_P < 3.0)), + F.FILTER( + F.require_any( + F.conditionally_skip(F.PID_P - F.PID_K < 1.0, label="PID"), + F.conditionally_skip(F.PID_P < 3.0, label="PID"), + ) + ), ) light_hadrons = ParticleContainersMerger( [light_long_hadrons, light_upstream_hadrons] @@ -5243,7 +5372,9 @@ def _filter_clones_of_light_hadrons(particles): > 0.999999875, ).OutputRelations clone_hyperons = SelectionFromRelationTable(InputRelations=rt).OutputLocation - return VoidFilter(Cut=F.SIZE(clone_hyperons) < F.SIZE(hyperon)) + return VoidFilter( + Cut=F.conditionally_skip(F.SIZE(clone_hyperons) < F.SIZE(hyperon)) + ) # Xib- -> pi- (Xic0 -> pi+ Xi-) @@ -5265,18 +5396,23 @@ def xibm_to_xicpi_xic_to_xipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(2, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) - > 240.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIP)) > 120 * um, - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 48.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 160.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, - bcdtf(_FDCHI2_CHILD(2)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(2, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 240.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIP)) > 120 * um), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 48.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 160.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(2)) > 1.0), ) ), ) @@ -5290,9 +5426,9 @@ def xibm_to_xicpi_xic_to_xipi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.9998, - bcmdtf(F.OWNPVIPCHI2) < 12.0, - bcmdtf(F.OWNPVIP) < 80.0 * um, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.9998), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 12.0), + F.conditionally_skip(bcmdtf(F.OWNPVIP) < 80.0 * um), ) ), ) @@ -5341,18 +5477,23 @@ def obm_to_ocpi_oc_to_opi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(2, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) - > 240.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIP)) > 120 * um, - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 48.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 160.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, - bcdtf(_FDCHI2_CHILD(2)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(2, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 240.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIP)) > 120 * um), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 48.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 160.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(2)) > 1.0), ) ), ) @@ -5366,9 +5507,9 @@ def obm_to_ocpi_oc_to_opi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.9998, - bcmdtf(F.OWNPVIPCHI2) < 12.0, - bcmdtf(F.OWNPVIP) < 80.0 * um, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.9998), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 12.0), + F.conditionally_skip(bcmdtf(F.OWNPVIP) < 80.0 * um), ) ), ) @@ -5409,7 +5550,7 @@ def lb_to_lcpi_lc_to_sppipi_v_line( DecayDescriptor="[Lambda_c+ -> pi- pi+ Sigma+]cc", name="Charm_Hyperons_LcpToPimPipSp_V_{hash}", Combination12Cut=F.require_all( - F.MIN(F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.MIN(F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAX(F.PT) > 560 * MeV, F.MIN(F.OWNPVIPCHI2) > 9.0, F.MAX(F.OWNPVIPCHI2) > 48.0, @@ -5438,16 +5579,21 @@ def lb_to_lcpi_lc_to_sppipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(2, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 8.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(2, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 8.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), ) ), ) @@ -5460,7 +5606,10 @@ def lb_to_lcpi_lc_to_sppipi_v_line( bb = ParticleFilter( bb_bcdtf, F.FILTER( - F.require_all(bcmdtf(F.OWNPVDIRA) > 0.999, bcmdtf(F.OWNPVIPCHI2) < 24.0) + F.require_all( + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 24.0), + ) ), ) @@ -5500,7 +5649,7 @@ def lb0_to_lcpi_lc_to_skk_v_line( DecayDescriptor="[Lambda_c+ -> K- K+ Sigma+]cc", name="Charm_Hyperons_LcpToKmKpSp_V_{hash}", Combination12Cut=F.require_all( - F.MAX(F.PROBNN_K) > 0.75, + F.conditionally_skip(F.MAX(F.PROBNN_K) > 0.75, label="PROBNN"), F.MAX(F.PT) > 650 * MeV, F.MAX(F.OWNPVIPCHI2) > 32.0, F.MASS < 1250 * MeV, @@ -5528,16 +5677,21 @@ def lb0_to_lcpi_lc_to_skk_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 8.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 8.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), ) ), ) @@ -5550,7 +5704,10 @@ def lb0_to_lcpi_lc_to_skk_v_line( bb = ParticleFilter( bb_bcdtf, F.FILTER( - F.require_all(bcmdtf(F.OWNPVDIRA) > 0.999, bcmdtf(F.OWNPVIPCHI2) < 24.0) + F.require_all( + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 24.0), + ) ), ) @@ -5598,16 +5755,21 @@ def xib0_to_xicpi_xic_to_xipipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 8.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 8.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), ) ), ) @@ -5620,7 +5782,10 @@ def xib0_to_xicpi_xic_to_xipipi_v_line( bb = ParticleFilter( bb_bcdtf, F.FILTER( - F.require_all(bcmdtf(F.OWNPVDIRA) > 0.999, bcmdtf(F.OWNPVIPCHI2) < 24.0) + F.require_all( + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 24.0), + ) ), ) @@ -5664,7 +5829,7 @@ def xib0_to_xicpi_xic_to_skpi_v_line( name="Charm_Hyperons_XicpToKmPipSp_V_{hash}", Combination12Cut=F.require_all( F.CHILD(2, F.PT) > 320 * MeV, - F.CHILD(2, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(2, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAX(F.PT) > 650 * MeV, F.MAX(F.OWNPVIPCHI2) > 48.0, F.MASS < 1430 * MeV, @@ -5692,16 +5857,21 @@ def xib0_to_xicpi_xic_to_skpi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 24.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 24.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), ) ), ) @@ -5714,7 +5884,10 @@ def xib0_to_xicpi_xic_to_skpi_v_line( bb = ParticleFilter( bb_bcdtf, F.FILTER( - F.require_all(bcmdtf(F.OWNPVDIRA) > 0.999, bcmdtf(F.OWNPVIPCHI2) < 24.0) + F.require_all( + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 24.0), + ) ), ) @@ -5754,7 +5927,7 @@ def xib0_to_xicpi_xic_to_skk_v_line( DecayDescriptor="[Xi_c+ -> K- K+ Sigma+]cc", name="Charm_Hyperons_XicpToKmKpSp_V_{hash}", Combination12Cut=F.require_all( - F.MAX(F.PROBNN_K) > 0.75, + F.conditionally_skip(F.MAX(F.PROBNN_K) > 0.75, label="PROBNN"), F.MAX(F.PT) > 650 * MeV, F.MAX(F.OWNPVIPCHI2) > 32.0, F.MASS < 1430 * MeV, @@ -5782,16 +5955,21 @@ def xib0_to_xicpi_xic_to_skk_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 8.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0, - bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0, - bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0, - bcdtf(_DZ_CHILD(2)) > -200 * um, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(2, F.CHILD(3, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 8.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVIPCHI2)) > 16.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVDLS)) > 6.0), + F.conditionally_skip(bcdtf(F.CHILD(2, F.OWNPVFDCHI2)) > 60.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(2)) > -200 * um), ) ), ) @@ -5804,7 +5982,10 @@ def xib0_to_xicpi_xic_to_skk_v_line( bb = ParticleFilter( bb_bcdtf, F.FILTER( - F.require_all(bcmdtf(F.OWNPVDIRA) > 0.999, bcmdtf(F.OWNPVIPCHI2) < 24.0) + F.require_all( + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 24.0), + ) ), ) @@ -5850,7 +6031,7 @@ def xibz_to_xicpipi_xic_to_xipi_v_line( DecayDescriptor="[Xi_b0 -> pi- pi+ Xi_c0]cc", name="Charm_Hyperons_Xib0ToPimPipXic0_Xic0ToPipXim_{hash}", Combination12Cut=F.require_all( - F.MIN(F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.MIN(F.PROBNN_PI) > 0.5, label="PROBNN"), F.MIN(F.OWNPVIPCHI2) > 12.0, F.MAX(F.OWNPVIPCHI2) > 48.0, F.MAX(F.PT) > 750 * MeV, @@ -5878,17 +6059,21 @@ def xibz_to_xicpipi_xic_to_xipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.4 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.PT)) > 2.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.CHILD(2, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) > 140.0, - bcdtf(F.CHILD(3, F.OWNPVIP)) > 120 * um, - bcdtf(F.CHILD(3, F.OWNPVIPCHI2)) > 48.0, - bcdtf(F.CHILD(3, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(3, F.OWNPVFDCHI2)) > 140.0, - bcdtf(_DZ_CHILD(3)) > -200 * um, - bcdtf(_FDCHI2_CHILD(3)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.4 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.PT)) > 2.2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.CHILD(2, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip(bcdtf(F.OWNPVFDCHI2) > 140.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVIP)) > 120 * um), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVIPCHI2)) > 48.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVFDCHI2)) > 140.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(3)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(3)) > 1.0), ) ), ) @@ -5902,8 +6087,8 @@ def xibz_to_xicpipi_xic_to_xipi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.999, - bcmdtf(F.OWNPVIPCHI2) < 12.0, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 12.0), ) ), ) @@ -5950,7 +6135,7 @@ def xibm_to_xicpipi_xicp_to_ximpipi_v_line( DecayDescriptor="[Xi_b- -> pi- pi- Xi_c+]cc", name="Charm_Hyperons_XibmToPimPimXicp_XicpToPipPipXim_{hash}", Combination12Cut=F.require_all( - F.MIN(F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.MIN(F.PROBNN_PI) > 0.5, label="PROBNN"), F.MIN(F.OWNPVIPCHI2) > 12.0, F.MAX(F.OWNPVIPCHI2) > 36.0, F.MAX(F.PT) > 750 * MeV, @@ -5978,17 +6163,22 @@ def xibm_to_xicpipi_xicp_to_ximpipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.PT)) > 2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.CHILD(3, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(3, F.OWNPVIPCHI2)) > 32.0, - bcdtf(F.CHILD(3, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(3, F.OWNPVFDCHI2)) > 140.0, - bcdtf(_DZ_CHILD(3)) > -200 * um, - bcdtf(_FDCHI2_CHILD(3)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.PT)) > 2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.CHILD(3, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVIPCHI2)) > 32.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVFDCHI2)) > 140.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(3)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(3)) > 1.0), ) ), ) @@ -6002,8 +6192,8 @@ def xibm_to_xicpipi_xicp_to_ximpipi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.999, - bcmdtf(F.OWNPVIPCHI2) < 12.0, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 12.0), ) ), ) @@ -6050,7 +6240,7 @@ def ob_to_xicpkmpim_xicp_to_ximpipi_v_line( DecayDescriptor="[Omega_b- -> K- pi- Xi_c+]cc", name="Charm_Hyperons_ObmToKmPimXicp_XicpToPipPipXim_{hash}", Combination12Cut=F.require_all( - F.CHILD(2, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(2, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MIN(F.OWNPVIPCHI2) > 9.0, F.MAX(F.OWNPVIPCHI2) > 32.0, F.MAX(F.PT) > 800 * MeV, @@ -6078,17 +6268,22 @@ def ob_to_xicpkmpim_xicp_to_ximpipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.PT)) > 2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.CHILD(3, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) - > 140.0, # we have too many NaNs in DLS, this is just for outlier removal - bcdtf(F.CHILD(3, F.OWNPVIPCHI2)) > 24.0, - bcdtf(F.CHILD(3, F.OWNPVDLS)) > 9.0, - bcdtf(F.CHILD(3, F.OWNPVFDCHI2)) > 140.0, - bcdtf(_DZ_CHILD(3)) > -200 * um, - bcdtf(_FDCHI2_CHILD(3)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.PT)) > 2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(3, F.CHILD(3, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip( + bcdtf(F.OWNPVFDCHI2) > 140.0 + ), # we have too many NaNs in DLS, this is just for outlier removal + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVIPCHI2)) > 24.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVDLS)) > 9.0), + F.conditionally_skip(bcdtf(F.CHILD(3, F.OWNPVFDCHI2)) > 140.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(3)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(3)) > 1.0), ) ), ) @@ -6102,9 +6297,9 @@ def ob_to_xicpkmpim_xicp_to_ximpipi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.999, - bcmdtf(F.OWNPVIPCHI2) < 16.0, - bcmdtf(F.OWNPVIP) < 120.0 * um, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 16.0), + F.conditionally_skip(bcmdtf(F.OWNPVIP) < 120.0 * um), ) ), ) @@ -6153,11 +6348,11 @@ def ob_to_xickpipi_xic_to_xipi_v_line( name="Charm_Hyperons_ObmToKmPimPipXic0_Xic0ToPipXim_{hash}", Combination12Cut=F.require_all( F.MASS < 3700 * MeV, - F.CHILD(2, F.PROBNN_PI) > 0.3, + F.conditionally_skip(F.CHILD(2, F.PROBNN_PI) > 0.3, label="PROBNN"), F.MAXSDOCACUT(150 * um), ), Combination123Cut=F.require_all( - F.CHILD(3, F.PROBNN_PI) > 0.3, + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.3, label="PROBNN"), F.MAX(F.OWNPVIPCHI2) > 48.0, F.MAX(F.PT) > 800 * MeV, F.SUM(F.PT) > 1.6 * GeV, @@ -6184,17 +6379,21 @@ def ob_to_xickpipi_xic_to_xipi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.PT)) > 2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.CHILD(2, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) > 90.0, - bcdtf(F.CHILD(4, F.OWNPVIPCHI2)) > 48.0, - bcdtf(F.CHILD(4, F.OWNPVIP)) > 120 * um, - bcdtf(F.CHILD(4, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(4, F.OWNPVFDCHI2)) > 140.0, - bcdtf(_DZ_CHILD(4)) > -200 * um, - bcdtf(_FDCHI2_CHILD(4)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.PT)) > 2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.CHILD(2, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip(bcdtf(F.OWNPVFDCHI2) > 90.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVIPCHI2)) > 48.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVIP)) > 120 * um), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVFDCHI2)) > 140.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(4)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(4)) > 1.0), ) ), ) @@ -6208,8 +6407,8 @@ def ob_to_xickpipi_xic_to_xipi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.999, - bcmdtf(F.OWNPVIPCHI2) < 12.0, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 12.0), ) ), ) @@ -6258,15 +6457,20 @@ def ob_to_ocpipipi_oc_to_opi_v_line( name="Charm_Hyperons_ObmToPimPimPipOc0_Oc0ToPipOm_{hash}", Combination12Cut=F.require_all( F.MASS < 3520 * MeV, - F.MAX(F.PROBNN_PI) > 0.6, + F.conditionally_skip(F.MAX(F.PROBNN_PI) > 0.6, label="PROBNN"), F.MAX(F.OWNPVIPCHI2) > 36.0, F.MAX(F.PT) > 640 * MeV, F.MAXSDOCACUT(150 * um), ), Combination123Cut=F.require_all( - F.MIN(F.PROBNN_PI) > 0.3, - F.CHILD(1, F.PROBNN_PI) * F.CHILD(2, F.PROBNN_PI) * F.CHILD(3, F.PROBNN_PI) - > 0.2, + F.conditionally_skip(F.MIN(F.PROBNN_PI) > 0.3, label="PROBNN"), + F.conditionally_skip( + F.CHILD(1, F.PROBNN_PI) + * F.CHILD(2, F.PROBNN_PI) + * F.CHILD(3, F.PROBNN_PI) + > 0.2, + label="PROBNN", + ), F.MAX(F.OWNPVIPCHI2) > 64.0, F.MAX(F.PT) > 800 * MeV, F.SUM(F.PT) > 1.8 * GeV, @@ -6293,17 +6497,22 @@ def ob_to_ocpipipi_oc_to_opi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.PT)) > 2.4 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.CHILD(2, F.PT))) > 1.2 * GeV, - bcdtf(F.OWNPVDLS) > 16.0, - bcdtf(F.OWNPVFDCHI2) > 120.0, - bcdtf(F.CHILD(4, F.OWNPVIPCHI2)) > 48.0, - bcdtf(F.CHILD(4, F.OWNPVIP)) > 120 * um, - bcdtf(F.CHILD(4, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(4, F.OWNPVFDCHI2)) > 140.0, - bcdtf(_DZ_CHILD(4)) > -200 * um, - bcdtf(_FDCHI2_CHILD(4)) > 1.5, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.6 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.PT)) > 2.4 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.CHILD(2, F.PT))) + > 1.2 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 16.0), + F.conditionally_skip(bcdtf(F.OWNPVFDCHI2) > 120.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVIPCHI2)) > 48.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVIP)) > 120 * um), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVFDCHI2)) > 140.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(4)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(4)) > 1.5), ) ), ) @@ -6317,8 +6526,8 @@ def ob_to_ocpipipi_oc_to_opi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.999, - bcmdtf(F.OWNPVIPCHI2) < 9.0, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 9.0), ) ), ) @@ -6371,7 +6580,7 @@ def ob_to_ockkpi_oc_to_opi_v_line( F.MAXSDOCACUT(150 * um), ), Combination123Cut=F.require_all( - F.CHILD(3, F.PROBNN_PI) > 0.3, + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.3, label="PROBNN"), F.MAX(F.OWNPVIPCHI2) > 48.0, F.MAX(F.PT) > 800 * MeV, F.SUM(F.PT) > 1.6 * GeV, @@ -6398,16 +6607,20 @@ def ob_to_ockkpi_oc_to_opi_v_line( bb_bdtf, F.FILTER( F.require_all( - bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.PT)) > 2 * GeV, - bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.CHILD(2, F.PT))) > 1 * GeV, - bcdtf(F.OWNPVDLS) > 12.0, - bcdtf(F.OWNPVFDCHI2) > 90.0, - bcdtf(F.CHILD(4, F.OWNPVIPCHI2)) > 24.0, - bcdtf(F.CHILD(4, F.OWNPVDLS)) > 8.0, - bcdtf(F.CHILD(4, F.OWNPVFDCHI2)) > 140.0, - bcdtf(_DZ_CHILD(4)) > -200 * um, - bcdtf(_FDCHI2_CHILD(4)) > 1.0, + F.conditionally_skip(bcdtf(F.VALUE_OR(Value=0) @ F.PT) > 3.2 * GeV), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.PT)) > 2 * GeV + ), + F.conditionally_skip( + bcdtf(F.VALUE_OR(Value=0) @ F.CHILD(4, F.CHILD(2, F.PT))) > 1 * GeV + ), + F.conditionally_skip(bcdtf(F.OWNPVDLS) > 12.0), + F.conditionally_skip(bcdtf(F.OWNPVFDCHI2) > 90.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVIPCHI2)) > 24.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVDLS)) > 8.0), + F.conditionally_skip(bcdtf(F.CHILD(4, F.OWNPVFDCHI2)) > 140.0), + F.conditionally_skip(bcdtf(_DZ_CHILD(4)) > -200 * um), + F.conditionally_skip(bcdtf(_FDCHI2_CHILD(4)) > 1.0), ) ), ) @@ -6421,8 +6634,8 @@ def ob_to_ockkpi_oc_to_opi_v_line( bb_bcdtf, F.FILTER( F.require_all( - bcmdtf(F.OWNPVDIRA) > 0.999, - bcmdtf(F.OWNPVIPCHI2) < 12.0, + F.conditionally_skip(bcmdtf(F.OWNPVDIRA) > 0.999), + F.conditionally_skip(bcmdtf(F.OWNPVIPCHI2) < 12.0), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperonsTT.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperonsTT.py index 32a393bcab8..b97bf58b6a7 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperonsTT.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/hyperonsTT.py @@ -81,7 +81,7 @@ def _make_long_pions_for_xi(): F.PT > 150 * MeV, F.MINIPCHI2(pvs) > 8.0, F.GHOSTPROB < 0.5, - F.PROBNN_PI > 0.2, + F.conditionally_skip(F.PROBNN_PI > 0.2, label="PROBNN"), ) ), ) @@ -97,7 +97,7 @@ def _make_down_pions_for_xi(): F.MINIPCHI2(pvs) > 25.0, F.GHOSTPROB < 0.5, F.CHI2DOF < 4.0, - F.PROBNN_PI > 0.2, + F.conditionally_skip(F.PROBNN_PI > 0.2, label="PROBNN"), ) ), ) @@ -115,9 +115,9 @@ def _make_loose_pions_for_charm(): F.PT > 250 * MeV, F.P > 3.5 * GeV, F.MINIPCHI2(pvs) > 3.0, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.GHOSTPROB < 0.5, - F.PROBNN_PI > 0.2, + F.conditionally_skip(F.PROBNN_PI > 0.2, label="PROBNN"), ), ), ) @@ -132,9 +132,9 @@ def _make_loose_kaons_for_charm(): F.PT > 500 * MeV, F.P > 10 * GeV, F.MINIPCHI2(pvs) > 3.0, - F.PID_K > -2.0, + F.conditionally_skip(F.PID_K > -2.0, label="PID"), F.GHOSTPROB < 0.5, - F.PROBNN_K > 0.1, + F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) ), ) @@ -149,9 +149,9 @@ def _make_loose_down_pions_for_charm(): F.PT > 150 * MeV, F.P > 2 * GeV, F.MINIPCHI2(pvs) > 3.0, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.GHOSTPROB < 0.5, - F.PROBNN_PI > 0.2, + F.conditionally_skip(F.PROBNN_PI > 0.2, label="PROBNN"), ) ), ) @@ -166,9 +166,9 @@ def _make_loose_down_kaons_for_charm(): F.PT > 150 * MeV, F.P > 2 * GeV, F.MINIPCHI2(pvs) > 2.0, - F.PID_K > -2.0, + F.conditionally_skip(F.PID_K > -2.0, label="PID"), F.GHOSTPROB < 0.5, - F.PROBNN_K > 0.1, + F.conditionally_skip(F.PROBNN_K > 0.1, label="PROBNN"), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/lc_to_pks_pkshh.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/lc_to_pks_pkshh.py index bfc82e243ea..0640e883a41 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/lc_to_pks_pkshh.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/lc_to_pks_pkshh.py @@ -67,7 +67,7 @@ def filter_long_pions( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -80,7 +80,7 @@ def filter_long_pions_from_strange( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < pion_pidk_max, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), ) return ParticleFilter(make_has_rich_long_pions(), F.FILTER(cut)) @@ -93,8 +93,8 @@ def filter_long_kaons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > pidk_min, - (F.PID_K - F.PID_P > ddl_min), + F.conditionally_skip(F.PID_K > pidk_min, label="PID"), + F.conditionally_skip((F.PID_K - F.PID_P > ddl_min), label="PID"), ) return ParticleFilter(make_has_rich_long_kaons(), F.FILTER(cut)) @@ -115,16 +115,20 @@ def filter_long_protons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > pidp_min, - (F.PID_P - F.PID_K) > dllp_min, - F.PROBNN_P > probnn_min, + F.conditionally_skip(F.PID_P > pidp_min, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > dllp_min, label="PID"), + F.conditionally_skip(F.PROBNN_P > probnn_min, label="PROBNN"), ) return ParticleFilter(make_has_rich_long_protons(), F.FILTER(cut)) def filter_down_pions(pt_min=300 * MeV, p_min=2 * GeV, pion_pidk_max=3.0): """Filter downstream pions with P PT, and PID_P cuts.""" - cut = F.require_all(F.PT > pt_min, F.P > p_min, F.PID_K < pion_pidk_max) + cut = F.require_all( + F.PT > pt_min, + F.P > p_min, + F.conditionally_skip(F.PID_K < pion_pidk_max, label="PID"), + ) return ParticleFilter(make_has_rich_down_pions(), F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/prod_xsec.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/prod_xsec.py index 8bafcaa5aec..2e0643600c3 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/prod_xsec.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/prod_xsec.py @@ -138,7 +138,7 @@ def _xsec_make_loose_long_pions_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), ), ), @@ -157,7 +157,7 @@ def _xsec_make_long_pions_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), ), ), @@ -179,7 +179,7 @@ def _xsec_make_loose_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), ), ), @@ -198,7 +198,7 @@ def _xsec_make_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), ), ), @@ -694,7 +694,7 @@ def _xsec_make_protons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > dllp_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), ) ), ) @@ -723,7 +723,7 @@ def _xsec_make_kaons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ), ), ) @@ -752,7 +752,7 @@ def _xsec_make_pions_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_lines.py index 8b282635a4f..d86359c792e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_lines.py @@ -4357,7 +4357,7 @@ def b2dmu_d2kspicontrol_line( def Lc2pgamma_ee_line(name="Hlt2Charm_LcpToPpG_EmEp", prescale=1): protons = m.make_rarecharm_protons_tightIPCut() electrons = m.make_rarecharm_electrons_no_brem( - pid_cut=F.PID_E > 3.0, with_downstream=True + pid_cut=F.conditionally_skip(F.PID_E > 3.0, label="PID"), with_downstream=True ) dielectrons = m.make_rarecharm_TwoElectrons_with_brem( electrons=electrons, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_makers.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_makers.py index 509cde7a7fc..167bd16271f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_makers.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/rare_charm_makers.py @@ -109,16 +109,24 @@ _TRACK_IPCHI2_MIN_PI_FROMTAU = 49.0 """****************************************""" """PID cuts""" """****************************************""" -_PID_MU = F.PID_MU > 0.0 -_PID_E = F.PID_E > 3.0 -_PID_K = F.PID_K > 0.0 -_PID_PI = F.PID_K < 0.0 -_PID_P = F.PID_P > 0.0 -_PID_PI_TIGHT = F.PID_K < -10.0 # pi from tau decays -_PID_P_TIGHT = F.PID_P > 10.0 # for two body D->pl decays -_PID_E_TIGHT = F.PID_E > 8.0 # for two body D->pl decays -_PID_PI_FROMKS = F.PID_K < 0.0 # pions from Ks decays -_PID_P_FROMLAMBDA = F.PID_P > -5.0 # protons from lambda decays +_PID_MU = F.conditionally_skip(F.PID_MU > 0.0, label="PID") +_PID_E = F.conditionally_skip(F.PID_E > 3.0, label="PID") +_PID_K = F.conditionally_skip(F.PID_K > 0.0, label="PID") +_PID_PI = F.conditionally_skip(F.PID_K < 0.0, label="PID") +_PID_P = F.conditionally_skip(F.PID_P > 0.0, label="PID") +_PID_PI_TIGHT = F.conditionally_skip(F.PID_K < -10.0, label="PID") # pi from tau decays +_PID_P_TIGHT = F.conditionally_skip( + F.PID_P > 10.0, label="PID" +) # for two body D->pl decays +_PID_E_TIGHT = F.conditionally_skip( + F.PID_E > 8.0, label="PID" +) # for two body D->pl decays +_PID_PI_FROMKS = F.conditionally_skip( + F.PID_K < 0.0, label="PID" +) # pions from Ks decays +_PID_P_FROMLAMBDA = F.conditionally_skip( + F.PID_P > -5.0, label="PID" +) # protons from lambda decays """****************************************""" """D->LL combiner""" """****************************************""" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/taggers.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/taggers.py index 5c3ab225bc3..98bb915b792 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/taggers.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charm/taggers.py @@ -89,7 +89,7 @@ def make_tagging_muons(): F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=make_pvs()), F.PT > 1 * GeV, F.P > 2 * GeV, - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charmonium_to_dimuon.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charmonium_to_dimuon.py index 342465d1665..36f14fa5733 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charmonium_to_dimuon.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/charmonium_to_dimuon.py @@ -69,7 +69,7 @@ def make_charmonium_muons( # ignoring minPIDmu cut here, thus ignoring it in ALL lines in this file if not nopid_muons() and minPIDmu is not None: - code &= F.require_all(F.PID_MU > minPIDmu) + code &= F.require_all(F.conditionally_skip(F.PID_MU > minPIDmu, label="PID")) if maxIPChi2_muon is not None: code &= F.OWNPVIPCHI2 < maxIPChi2_muon diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/commissioning.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/commissioning.py index 40430c2dc5e..f9983cff98b 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/commissioning.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/commissioning.py @@ -57,7 +57,7 @@ def _filter_long_pions_for_charm(): F.require_all( F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), _MIPCHI2_MIN(4), ), ), @@ -71,7 +71,7 @@ def _filter_long_kaons_for_charm(): F.require_all( F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), _MIPCHI2_MIN(4), ), ), @@ -83,7 +83,10 @@ def _filter_long_protons_for_strange(): make_long_protons(), F.FILTER( F.require_all( - F.PT > 400 * MeV, F.PID_P > -5.0, _MIP_MIN(80.0 * um), _MIPCHI2_MIN(9) + F.PT > 400 * MeV, + F.conditionally_skip(F.PID_P > -5.0, label="PID"), + _MIP_MIN(80.0 * um), + _MIPCHI2_MIN(9), ) ), ) @@ -94,7 +97,10 @@ def _filter_long_protons_for_charm(): make_long_protons(), F.FILTER( F.require_all( - F.PT > 600 * MeV, F.PID_P > 5.0, _MIP_MIN(20.0 * um), _MIPCHI2_MIN(4) + F.PT > 600 * MeV, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + _MIP_MIN(20.0 * um), + _MIPCHI2_MIN(4), ) ), ) @@ -107,8 +113,8 @@ def _filter_photons(): F.require_all( F.PT > 300 * MeV, F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > 0.9, - F.IS_PHOTON > 0.7, - F.IS_NOT_H > 0.5, + F.conditionally_skip(F.IS_PHOTON > 0.7, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.5, label="IS_NOT_H"), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/hlt2_line_example.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/hlt2_line_example.py index 41ea0f812da..126e0ceecdd 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/hlt2_line_example.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/hlt2_line_example.py @@ -51,7 +51,7 @@ def _protons_for_charm(): cut = F.require_all( F.PT > 0.5 * GeV, F.MINIPCHI2(pvs) > 9.0, - F.PID_P > 5.0, + F.conditionally_skip(F.PID_P > 5.0, label="PID"), ) return ParticleFilter( make_has_rich_long_protons(), @@ -66,7 +66,7 @@ def _kaons_for_charm(): cut = F.require_all( F.PT > 0.5 * GeV, F.MINIPCHI2(pvs) > 9.0, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ) return ParticleFilter( make_has_rich_long_kaons(), @@ -84,7 +84,7 @@ def _pions_for_charm_and_beauty(pt_min=0.5 * GeV): F.PT > pt_min, F.MINIPCHI2(pvs) > 9.0, # PID_X is a likelihood ratio of X w.r.t. the pion hypothesis. PID_PI is 0 by definition. - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) return ParticleFilter( make_has_rich_long_pions(), @@ -174,7 +174,7 @@ def lb0tolcpmum_line( muon_cut = F.require_all( F.PT > 1 * GeV, F.MINIPCHI2(pvs) > 9.0, - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ) muons = ParticleFilter( make_ismuon_long_muon(), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_CEP_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_CEP_builders.py index 9a59b1a41bc..4b90717047d 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_CEP_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_CEP_builders.py @@ -55,13 +55,13 @@ def make_smog2_particle_no_PV( if pid_cut is not None: if particle == "Muon": - code &= F.PID_MU > pid_cut + code &= F.conditionally_skip(F.PID_MU > pid_cut, label="PID") elif particle == "Pion": - code &= F.PID_K < pid_cut + code &= F.conditionally_skip(F.PID_K < pid_cut, label="PID") elif particle == "Kaon": - code &= F.PID_K > pid_cut + code &= F.conditionally_skip(F.PID_K > pid_cut, label="PID") elif particle == "Proton": - code &= F.PID_P > pid_cut + code &= F.conditionally_skip(F.PID_P > pid_cut, label="PID") return ParticleFilter(make_particles(), Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_builders.py index aa0c334258d..f8d987563ef 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_builders.py @@ -73,13 +73,13 @@ def make_smog2_common_particles( if pid_cut is not None: if particle == "Muon": - code &= F.PID_MU > pid_cut + code &= F.conditionally_skip(F.PID_MU > pid_cut, label="PID") elif particle == "Pion": - code &= F.PID_K < pid_cut + code &= F.conditionally_skip(F.PID_K < pid_cut, label="PID") elif particle == "Kaon": - code &= F.PID_K > pid_cut + code &= F.conditionally_skip(F.PID_K > pid_cut, label="PID") elif particle == "Proton": - code &= F.PID_P > pid_cut + code &= F.conditionally_skip(F.PID_P > pid_cut, label="PID") if min_bpvip: code &= F.OWNPVIP >= min_bpvip diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_chargedPID_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_chargedPID_builders.py index 33405fc51d2..16331e06a93 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_chargedPID_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_chargedPID_builders.py @@ -101,8 +101,8 @@ def make_tight_tag_pion(pion, pvs): F.CHI2DOF < 3, F.PT > 400 * MeV, F.GHOSTPROB < 0.4, - F.PID_P < 0, - F.PID_K < 0, + F.conditionally_skip(F.PID_P < 0, label="PID"), + F.conditionally_skip(F.PID_K < 0, label="PID"), F.P > 3 * GeV, F.ETA > 2, F.ETA < 5, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_charm_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_charm_builders.py index 024ade6a7d9..74be745c243 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_charm_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_charm_builders.py @@ -154,7 +154,7 @@ def make_charm_protons_tight( pvinsmog2=True, ) - code = (F.PID_P - F.PID_K) > minPIDProtonKaon + code = F.conditionally_skip((F.PID_P - F.PID_K) > minPIDProtonKaon, label="PID") return ParticleFilter(protons, Cut=F.FILTER(code), name="TightProtons_{hash}") diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_muons_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_muons_builders.py index 60b78395cfd..6d14dff767e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_muons_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/builders/smog2_muons_builders.py @@ -98,7 +98,7 @@ def make_tag_muons( F.ISMUON, ) if pid_cut is not None: - code &= F.PID_MU > pid_cut + code &= F.conditionally_skip(F.PID_MU > pid_cut, label="PID") return ParticleFilter(tagmuons, F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_femtoscopy.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_femtoscopy.py index 4127bc71f20..0fd8381720f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_femtoscopy.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_femtoscopy.py @@ -71,7 +71,7 @@ def _make_kaons_from_omega( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ) ), ) @@ -103,8 +103,10 @@ def _make_prompt_protons( F.PT > pt_min, F.P > p_min, F.OWNPVIPCHI2 < mipchi2_max, - F.PID_P > dllp_min, - (F.PID_P - F.PID_K) > dllp_m_dllk_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), + F.conditionally_skip( + (F.PID_P - F.PID_K) > dllp_m_dllk_min, label="PID" + ), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_isolated_highpt_photon.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_isolated_highpt_photon.py index 4828c59c701..6d9c371c719 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_isolated_highpt_photon.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_isolated_highpt_photon.py @@ -43,7 +43,11 @@ for minPt, ps in prescales.items(): """ photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_He.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_He.py index e247b8c6228..1190d783c97 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_He.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_He.py @@ -97,7 +97,7 @@ def filter_protons(particles, pvs=None, ipchi2=5, track_chi2dof=2.0, pid_p=3): F.ETA > 2.0, F.OWNPVIPCHI2 >= ipchi2, F.CHI2DOF < track_chi2dof, - F.PID_P > pid_p, + F.conditionally_skip(F.PID_P > pid_p, label="PID"), ) return ParticleFilter(particles, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_high_mul_charm.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_high_mul_charm.py index 3f8935c4ccc..327766d2341 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_high_mul_charm.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_high_mul_charm.py @@ -72,7 +72,7 @@ def _xsec_make_loose_long_pions_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), ), ), @@ -86,7 +86,7 @@ def _xsec_make_long_pions_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), ), ), @@ -100,7 +100,7 @@ def _xsec_make_loose_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), ), ), @@ -114,7 +114,7 @@ def _xsec_make_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), ), ), @@ -474,7 +474,7 @@ def _xsec_make_protons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > dllp_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), ) ), ) @@ -494,7 +494,7 @@ def _xsec_make_kaons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ), ), ) @@ -514,7 +514,7 @@ def _xsec_make_pions_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_ref_2024.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_ref_2024.py index a0f9ac7f3b3..be4c6168b13 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_ref_2024.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_pp_ref_2024.py @@ -54,7 +54,11 @@ hlt1_filter_lambda = ["Hlt1SMOG2L0ToppiDecision"] def IsolatedGamma5GeVLine(name="Hlt2IFTFull_5GeVIsolatedGamma", minpt=5.0, prescale=1): photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) @@ -78,7 +82,11 @@ def IsolatedGamma10GeVLine( ): photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) @@ -102,7 +110,11 @@ def IsolatedGamma20GeVLine( ): photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_smog2_chargedPID.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_smog2_chargedPID.py index 200a7b1cde0..670f4744ed9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_smog2_chargedPID.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/hlt2_ift_smog2_chargedPID.py @@ -258,8 +258,8 @@ def smog2_displacedpi_line( ) code &= F.OWNPVIP >= 1 * mm code &= F.OWNPVIPCHI2 >= min_bpvipchi2 - code &= F.PID_K < 0 - code &= F.PID_P < 0 + code &= F.conditionally_skip(F.PID_K < 0, label="PID") + code &= F.conditionally_skip(F.PID_P < 0, label="PID") code &= bpv_in_smog2(pvs) displaced_pions = ParticleFilter(make_has_rich_long_pions(), Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_isolated_highpt_photon.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_isolated_highpt_photon.py index 194148867ca..e49d6771ede 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_isolated_highpt_photon.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_isolated_highpt_photon.py @@ -38,7 +38,11 @@ def Spruce_5GeVIsolatedGamma_line( """ photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) @@ -62,7 +66,11 @@ def Spruce_10GeVIsolatedGamma_line( """ photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) @@ -86,7 +94,11 @@ def Spruce_20GeVIsolatedGamma_line( """ photons = make_photons() - code = F.require_all(F.PT > minpt * GeV, F.IS_PHOTON > 0.8, F.IS_NOT_H > 0.8) + code = F.require_all( + F.PT > minpt * GeV, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.8, label="IS_NOT_H"), + ) highpt_photons = ParticleFilter(Input=photons, Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_pp_high_mul_charm.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_pp_high_mul_charm.py index bd3c81610b9..cdebb60bfe4 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_pp_high_mul_charm.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_pp_high_mul_charm.py @@ -76,7 +76,7 @@ def _xsec_make_loose_long_pions_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), ), ), @@ -90,7 +90,7 @@ def _xsec_make_long_pions_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), ), ), @@ -104,7 +104,7 @@ def _xsec_make_loose_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), ), ), @@ -118,7 +118,7 @@ def _xsec_make_long_kaons_from_d() -> ParticleFilter: F.require_all( F.PT > 250 * MeV, F.P > 2 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), F.MINIPCHI2CUT(IPChi2Cut=16.0, Vertices=make_pvs()), ), ), @@ -525,7 +525,7 @@ def _xsec_make_protons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_P > dllp_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), ) ), ) @@ -545,7 +545,7 @@ def _xsec_make_kaons_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ), ), ) @@ -565,7 +565,7 @@ def _xsec_make_pions_from_baryons( F.PT > pt_min, F.P > p_min, F.MINIPCHI2CUT(IPChi2Cut=mipchi2_min, Vertices=pvs), - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_smog2_chargedPID.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_smog2_chargedPID.py index c273ec5717c..be27f27f839 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_smog2_chargedPID.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/ift/spruce_ift_smog2_chargedPID.py @@ -299,8 +299,8 @@ def smog2_displacedpi_spruceline( ) code &= F.OWNPVIP >= 1 * mm code &= F.OWNPVIPCHI2 >= min_bpvipchi2 - code &= F.PID_K < 0 - code &= F.PID_P < 0 + code &= F.conditionally_skip(F.PID_K < 0, label="PID") + code &= F.conditionally_skip(F.PID_P < 0, label="PID") code &= bpv_in_smog2(pvs) displaced_pions = ParticleFilter(make_has_rich_long_pions(), Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/iftPbPb/SMOG2_Jpsi_trackeff.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/iftPbPb/SMOG2_Jpsi_trackeff.py index 737a13ab9d7..755a79583cc 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/iftPbPb/SMOG2_Jpsi_trackeff.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/iftPbPb/SMOG2_Jpsi_trackeff.py @@ -140,7 +140,7 @@ def make_TagFilter( F.P > get_cuts["min_TagP"], F.PT > get_cuts["min_TagPT"], F.ISMUON(), - F.PID_MU > get_cuts["min_TagMuonID"], + F.conditionally_skip(F.PID_MU > get_cuts["min_TagMuonID"], label="PID"), F.GHOSTPROB() < get_cuts["max_TagGhostProb"], ) return ParticleFilter(particles, F.FILTER(code), name=name) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/inclusive_detached_dilepton/dilepton_mva_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/inclusive_detached_dilepton/dilepton_mva_builder.py index 4606c436ef4..3ea5a86331d 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/inclusive_detached_dilepton/dilepton_mva_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/inclusive_detached_dilepton/dilepton_mva_builder.py @@ -123,9 +123,11 @@ def make_inclusive_dilepton_detached_dimuon( Make the detached dimuon, opposite-sign or same-sign. """ if IsMuon: - pid = F.require_all(F.ISMUON, F.PID_MU > pidmu_muon_min) + pid = F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > pidmu_muon_min, label="PID") + ) else: - pid = F.PID_MU > pidmu_muon_min + pid = F.conditionally_skip(F.PID_MU > pidmu_muon_min, label="PID") muons = make_rd_detached_muons( name="rd_detached_muons_{hash}", diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/calibmon.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/calibmon.py index d6caa60e325..847b90d3a7f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/calibmon.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/calibmon.py @@ -896,7 +896,12 @@ def calibmon_b_to_jpsi_k_jpsi_to_em_ep_tagged( kaons = ParticleFilter( make_long_kaons(), F.FILTER( - F.require_all(F.PT > 1 * GeV, F.P > 3 * GeV, F.OWNPVIPCHI2 > 9, F.PID_K > 5) + F.require_all( + F.PT > 1 * GeV, + F.P > 3 * GeV, + F.OWNPVIPCHI2 > 9, + F.conditionally_skip(F.PID_K > 5, label="PID"), + ) ), ) es_tag = ParticleFilter( @@ -906,7 +911,7 @@ def calibmon_b_to_jpsi_k_jpsi_to_em_ep_tagged( F.PT > 1.5 * GeV, F.P > 6 * GeV, F.OWNPVIPCHI2 > 9, - F.PID_E > 5, + F.conditionally_skip(F.PID_E > 5, label="PID"), F.GHOSTPROB < 0.65, ) ), @@ -970,18 +975,31 @@ def calibmon_b_to_jpsi_k_jpsi_to_em_ep_tagged( b_mass_part_dict, input=b_ep_tagged, variable=_get_dtf_mass(b_ep_tagged) - * (F.CHILD(1, F.CHILD(2, F.PID_E > pid_cut))), + * ( + F.CHILD( + 1, F.CHILD(2, F.conditionally_skip(F.PID_E > pid_cut, label="PID")) + ) + ), ) b_hist_dict[f"B_M_em_tagged_probe_PIDe_gt_{pid_cut}"] = dict( b_mass_part_dict, input=b_em_tagged, variable=_get_dtf_mass(b_em_tagged) - * (F.CHILD(1, F.CHILD(2, F.PID_E > pid_cut))), + * ( + F.CHILD( + 1, F.CHILD(2, F.conditionally_skip(F.PID_E > pid_cut, label="PID")) + ) + ), ) b_hist_dict[f"B_M_probe_PIDe_gt_{pid_cut}"] = dict( b_mass_part_dict, input=bs, - variable=_get_dtf_mass(bs) * (F.CHILD(1, F.CHILD(2, F.PID_E > pid_cut))), + variable=_get_dtf_mass(bs) + * ( + F.CHILD( + 1, F.CHILD(2, F.conditionally_skip(F.PID_E > pid_cut, label="PID")) + ) + ), ) b_hist_list = _make_hist_list(b_hist_dict, name) @@ -1344,7 +1362,7 @@ def calibmon_dimuon_velomuon(name="Hlt2CalibMon_DiMuon_VeloMuon"): F.CHI2DOF < 3, F.PT > 500 * MeV, F.P > 7 * GeV, - F.PID_MU > -1, + F.conditionally_skip(F.PID_MU > -1, label="PID"), F.MINIP(pvs) > 0.2 * mm, ) ), @@ -1443,7 +1461,7 @@ def calibmon_dimuon_downstream(name="Hlt2CalibMon_DiMuon_Downstream", prescale=0 F.CHI2DOF < 10, F.PT > 700 * MeV, F.P > 5 * GeV, - F.PID_MU > -2, + F.conditionally_skip(F.PID_MU > -2, label="PID"), F.GHOSTPROB() < 1, F.MINIP(pvs) > 0.5 * mm, ) @@ -1553,7 +1571,7 @@ def calibmon_dimuon_muonut(name="Hlt2CalibMon_DiMuon_MuonUT"): F.CHI2DOF < 5, F.PT > 1.3 * GeV, F.P > 10 * GeV, - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), F.GHOSTPROB() < 0.3, ) ), @@ -1650,7 +1668,7 @@ def calibmon_dimuon_seedmuon(name="Hlt2CalibMon_DiMuon_SeedMuon"): F.CHI2DOF < 3, F.PT > 500 * MeV, F.P > 10 * GeV, - F.PID_MU > -2, + F.conditionally_skip(F.PID_MU > -2, label="PID"), F.MINIP(pvs) > 0.1 * mm, _MIPCHI2_MIN(38), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/data_quality_PbPb.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/data_quality_PbPb.py index 0c7998cbc00..7255ee368fc 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/data_quality_PbPb.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/data_quality_PbPb.py @@ -57,7 +57,7 @@ def prompt_jpsi_to_mumu(): F.PT > 700 * MeV, F.MINIP(make_pvs()) < 80 * um, F.MINIPCHI2(make_pvs()) < 6, - F.PID_MU > 0, + F.conditionally_skip(F.PID_MU > 0, label="PID"), ) ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/BToJpsiK_JpsiToMuMuTagged.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/BToJpsiK_JpsiToMuMuTagged.py index 190b1ec5537..5a32f44c899 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/BToJpsiK_JpsiToMuMuTagged.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/BToJpsiK_JpsiToMuMuTagged.py @@ -51,7 +51,7 @@ def make_kaons( F.P > p_min, F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2dv_min, - F.PID_K > dllkpi_min, + F.conditionally_skip(F.PID_K > dllkpi_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/Bd2KstG_Bs2PhiG.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/Bd2KstG_Bs2PhiG.py index 0f897027b1f..23dd222e319 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/Bd2KstG_Bs2PhiG.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/Bd2KstG_Bs2PhiG.py @@ -43,7 +43,7 @@ def bs_to_phig_line(name="Hlt2PID_Bs2PhiG", prescale=1.0): k_p_min=2.0 * GeV, k_pt_min=500.0 * MeV, k_ipchi2_min=55.0, - k_pid=(F.PROBNN_K > 0.8), + k_pid=F.conditionally_skip((F.PROBNN_K > 0.8), label="PROBNN"), phi_pt_min=1500.0 * MeV, ) @@ -89,11 +89,11 @@ def bd_to_kstg_line(name="Hlt2PID_BdToKstG", prescale=1.0): pi_p_min=2.0 * GeV, pi_pt_min=500.0 * MeV, pi_ipchi2_min=100.0, - pi_pid=(F.PROBNN_PI > 0.85), + pi_pid=F.conditionally_skip((F.PROBNN_PI > 0.85), label="PROBNN"), k_p_min=2.0 * GeV, k_pt_min=500.0 * MeV, k_ipchi2_min=100.0, - k_pid=(F.PROBNN_K > 0.85), + k_pid=F.conditionally_skip((F.PROBNN_K > 0.85), label="PROBNN"), kstar0_pt_min=1500.0 * MeV, adocachi2cut=10.0, vchi2pdof_max=9.0, @@ -102,7 +102,9 @@ def bd_to_kstg_line(name="Hlt2PID_BdToKstG", prescale=1.0): # +/-100 MeV mass window and K<->pi mis-ID cut kst_filt_code = F.require_all( in_range(795.0 * MeV, F.MASS, 995.0 * MeV), - (F.CHILD(1, F.PID_K) - F.CHILD(2, F.PID_K)) > -5.0, + F.conditionally_skip( + (F.CHILD(1, F.PID_K) - F.CHILD(2, F.PID_K)) > -5.0, label="PID" + ), ) kst_filt = ParticleFilter( kst, F.FILTER(kst_filt_code), name="filt_PID_BdToKstG_Kst_{hash}" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/DsToPhiPi_PhiToMuMuTagged.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/DsToPhiPi_PhiToMuMuTagged.py index c84f348843a..ebb4fb2d331 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/DsToPhiPi_PhiToMuMuTagged.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/DsToPhiPi_PhiToMuMuTagged.py @@ -73,7 +73,7 @@ def make_pions( F.P > p_min, F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2dv_min, - F.PID_K < dllkpi_max, + F.conditionally_skip(F.PID_K < dllkpi_max, label="PID"), ) return ParticleFilter(particles, F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/PhiToKK_Detached.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/PhiToKK_Detached.py index b041ef595a8..480e65e8b4c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/PhiToKK_Detached.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/PhiToKK_Detached.py @@ -50,7 +50,7 @@ def make_tag_kaons( F.P > p_min, F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2dv_min, - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ) return ParticleFilter(particles, F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/charmonium.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/charmonium.py index 8b50a4d6c14..82c77e931e0 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/charmonium.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/charmonium.py @@ -83,7 +83,7 @@ def make_tag_electrons( ), F.FILTER( F.require_all( - F.PID_E > dlle_min, + F.conditionally_skip(F.PID_E > dlle_min, label="PID"), F.CHARGE > 0 if charge > 0 else F.CHARGE < 0, ), ), @@ -265,7 +265,7 @@ def make_electrons_for_dielectron_PIDe( & (F.PT > tag_pt_min) & (F.P > tag_p_min) & (F.MINIPCHI2(pvs) > tag_mipchi2_min) - & (F.PID_E > tag_dlle_min) + & F.conditionally_skip((F.PID_E > tag_dlle_min), label="PID") ) | ( (F.CHARGE < 0) @@ -289,7 +289,7 @@ def make_electrons_for_dielectron_PIDe( & (F.PT > tag_pt_min) & (F.P > tag_p_min) & (F.MINIPCHI2(pvs) > tag_mipchi2_min) - & (F.PID_E > tag_dlle_min) + & F.conditionally_skip((F.PID_E > tag_dlle_min), label="PID") ) | ( (F.CHARGE > 0) @@ -384,7 +384,7 @@ def make_tag_protons( F.FILTER( F.require_all( F.GHOSTPROB < ghostprob_max, - F.PID_P > dllp_min, + F.conditionally_skip(F.PID_P > dllp_min, label="PID"), F.CHARGE > 0 if charge > 0 else F.CHARGE < 0, ), ), diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/filters.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/filters.py index 6adec41c0a2..46934949c63 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/filters.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/filters.py @@ -63,26 +63,26 @@ def filter_particles_dll(particles, dll_lim, dll_type, min): if min: if dll_type == "mu": - code = F.require_all(F.PID_MU > dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_MU > dll_lim, label="PID")) if dll_type == "e": - code = F.require_all(F.PID_E > dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_E > dll_lim, label="PID")) if dll_type == "k": - code = F.require_all(F.PID_K > dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_K > dll_lim, label="PID")) if dll_type == "pi": - code = F.require_all(F.PID_PI > dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_PI > dll_lim, label="PID")) if dll_type == "p": - code = F.require_all(F.PID_P > dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_P > dll_lim, label="PID")) else: if dll_type == "mu": - code = F.require_all(F.PID_MU < dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_MU < dll_lim, label="PID")) if dll_type == "e": - code = F.require_all(F.PID_E < dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_E < dll_lim, label="PID")) if dll_type == "k": - code = F.require_all(F.PID_K < dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_K < dll_lim, label="PID")) if dll_type == "pi": - code = F.require_all(F.PID_PI < dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_PI < dll_lim, label="PID")) if dll_type == "p": - code = F.require_all(F.PID_P < dll_lim) + code = F.require_all(F.conditionally_skip(F.PID_P < dll_lim, label="PID")) return ParticleFilter(particles, F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/neutral_pid.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/neutral_pid.py index 0f4fc03eb9f..e0f837ff0bd 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/neutral_pid.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/pid/utils/neutral_pid.py @@ -46,7 +46,7 @@ def make_prompt_slow_pions( code = F.require_all( F.PT > pt_min, F.P > p_min, - F.PROBNN_PI > 0.85, + F.conditionally_skip(F.PROBNN_PI > 0.85, label="PROBNN"), F.MINIPCHI2(pvs) < mipchi2dvprimary_max, ) @@ -87,7 +87,7 @@ def make_calib_has_rich_detached_pions( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K <= 0.0), + pid=F.conditionally_skip((F.PID_K <= 0.0), label="PID"), ): """ Return RD detached pions with hasRich. @@ -108,7 +108,7 @@ def make_calib_has_rich_detached_kaons( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): """ Return RD detached kaons with hasRich. @@ -133,7 +133,7 @@ def make_calib_detached_phis( k_p_min=2.0 * GeV, k_pt_min=100.0 * MeV, k_ipchi2_min=4.0, - k_pid=(F.PID_K > 0.0), + k_pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), phi_pt_min=400.0 * MeV, adocachi2cut=30.0, vchi2pdof_max=25.0, @@ -172,11 +172,11 @@ def make_calib_detached_kstar0s( pi_p_min=2.0 * GeV, pi_pt_min=100.0 * MeV, pi_ipchi2_min=4.0, - pi_pid=(F.PID_K < 8.0), + pi_pid=F.conditionally_skip((F.PID_K < 8.0), label="PID"), k_p_min=2.0 * GeV, k_pt_min=100.0 * MeV, k_ipchi2_min=4.0, - k_pid=(F.PID_K > -2.0), + k_pid=F.conditionally_skip((F.PID_K > -2.0), label="PID"), kstar0_pt_min=400.0 * MeV, adocachi2cut=30.0, vchi2pdof_max=25.0, @@ -228,18 +228,20 @@ def make_DstDz2Kpipiz( # can be resolved or merged pi_p_min=2.0 * GeV, pi_pt_min=track_pt_min, pi_ipchi2_min=25.0, - pi_pid=(F.PROBNN_PI > 0.9), + pi_pid=F.conditionally_skip((F.PROBNN_PI > 0.9), label="PROBNN"), k_p_min=2.0 * GeV, k_pt_min=track_pt_min, k_ipchi2_min=25.0, - k_pid=(F.PROBNN_K > 0.9), + k_pid=F.conditionally_skip((F.PROBNN_K > 0.9), label="PROBNN"), kstar0_pt_min=1000.0 * MeV, adocachi2cut=30.0, vchi2pdof_max=9.0, ) Kpi_filt_code = F.require_all( - (F.CHILD(1, F.PID_K) - F.CHILD(2, F.PID_K)) > 0.0, # extra + F.conditionally_skip( + (F.CHILD(1, F.PID_K) - F.CHILD(2, F.PID_K)) > 0.0, label="PID" + ), # extra ) Kpi = ParticleFilter(Kpi, F.FILTER(Kpi_filt_code), name=name + "_Kpi") @@ -330,11 +332,18 @@ def make_prompt_ds(name="pid_prompt_ds"): k_code = F.require_all( F.PT > 500.0 * MeV, F.MINIPCHI2(pvs) > 10.0, - ((F.PID_K > 5.0) & ((F.PID_K - F.PID_P) > 0)), + ( + F.conditionally_skip((F.PID_K > 5.0), label="PID") + & F.conditionally_skip(((F.PID_K - F.PID_P) > 0), label="PID") + ), ) kaon = ParticleFilter(make_has_rich_long_kaons(), F.FILTER(k_code), name="pid_kaon") - pi_code = F.require_all(F.PT > 300.0 * MeV, F.MINIPCHI2(pvs) > 10.0, F.PID_K < -1.0) + pi_code = F.require_all( + F.PT > 300.0 * MeV, + F.MINIPCHI2(pvs) > 10.0, + F.conditionally_skip(F.PID_K < -1.0, label="PID"), + ) pion = ParticleFilter( make_has_rich_long_pions(), F.FILTER(pi_code), name="pid_pion" ) @@ -373,7 +382,7 @@ def make_prompt_dimuons(name="pid_prompt_dimuon"): F.PT > 500.0 * MeV, F.P > 10000.0 * MeV, F.MINIPCHI2(pvs) < 10.0, - F.PID_MU > 3.0, + F.conditionally_skip(F.PID_MU > 3.0, label="PID"), F.ISMUON, ) prompt_muon = ParticleFilter( @@ -406,7 +415,10 @@ def make_prompt_dimuons(name="pid_prompt_dimuon"): def make_d2etappi(name="pid_d2etappi"): pvs = make_pvs() pi_code = F.require_all( - F.PT > 500.0 * MeV, F.P > 1000.0 * MeV, F.MINIPCHI2(pvs) > 12.0, F.PID_K < 0.0 + F.PT > 500.0 * MeV, + F.P > 1000.0 * MeV, + F.MINIPCHI2(pvs) > 12.0, + F.conditionally_skip(F.PID_K < 0.0, label="PID"), ) pi = ParticleFilter(make_has_rich_long_pions(), F.FILTER(pi_code), name="pi") diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/b_to_majolep_majo_to_leplep.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/b_to_majolep_majo_to_leplep.py index 5db96763842..7de75d7b72b 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/b_to_majolep_majo_to_leplep.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/b_to_majolep_majo_to_leplep.py @@ -119,10 +119,10 @@ defaultCutDict = { }, } -child_muon_pidCut = [F.ISMUON, F.PID_MU > 0.0] -bach_muon_pidCut = [F.ISMUON, F.PID_MU > 2] +child_muon_pidCut = [F.ISMUON, F.conditionally_skip(F.PID_MU > 0.0, label="PID")] +bach_muon_pidCut = [F.ISMUON, F.conditionally_skip(F.PID_MU > 2, label="PID")] -electron_pidCut = [F.PID_E > 0.0] +electron_pidCut = [F.conditionally_skip(F.PID_E > 0.0, label="PID")] particle_makers = { "L": {"e": make_long_electrons_with_brem, "mu": make_long_muons}, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dielectron_persist_photons.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dielectron_persist_photons.py index fb3bb465dd1..738c829ab06 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dielectron_persist_photons.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dielectron_persist_photons.py @@ -53,8 +53,8 @@ def photon_filter( code = F.require_all( F.PT > et_min, F.P > e_min, - F.IS_PHOTON > is_photon_min, - F.IS_NOT_H > is_not_h_min, + F.conditionally_skip(F.IS_PHOTON > is_photon_min, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > is_not_h_min, label="IS_NOT_H"), F.CALO_NEUTRAL_SHOWER_SHAPE > shower_shape_min, ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dimuon_no_ip.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dimuon_no_ip.py index dfbbfcc97c6..5f1cfabfdf0 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dimuon_no_ip.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/dimuon_no_ip.py @@ -36,7 +36,7 @@ def filter_muons(particles, pvs, min_ipchi2, pid_mu, use_pid=True, p_min=5 * GeV F.MINIPCHI2CUT(IPChi2Cut=min_ipchi2, Vertices=pvs), ) if use_pid: - cut = (F.PID_MU > pid_mu) & cut + cut = F.conditionally_skip((F.PID_MU > pid_mu), label="PID") & cut return ParticleFilter(particles, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/diphoton.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/diphoton.py index 075f03270d7..7db9bcadee3 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/diphoton.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/diphoton.py @@ -45,8 +45,8 @@ def filter_qee_photons( code = F.require_all( F.PT > et_min, F.P > e_min, - F.IS_NOT_H > cl_min, - F.IS_PHOTON > isph_min, + F.conditionally_skip(F.IS_NOT_H > cl_min, label="IS_NOT_H"), + F.conditionally_skip(F.IS_PHOTON > isph_min, label="IS_PHOTON"), ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan.py index 696bd6670b1..b393eef117c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan.py @@ -62,7 +62,7 @@ def filter_muons( in_range(min_eta, F.ETA, max_eta), F.PT >= min_pt, F.P >= min_p, - F.PID_MU >= min_pidmu, + F.conditionally_skip(F.PID_MU >= min_pidmu, label="PID"), in_range(min_ip, F.OWNPVIP, max_ip), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan_pp_ref_2024.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan_pp_ref_2024.py index 5033f855cd5..7e1ac0364c4 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan_pp_ref_2024.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/drellyan_pp_ref_2024.py @@ -66,7 +66,7 @@ def filter_muons( in_range(min_eta, F.ETA, max_eta), F.PT >= min_pt, F.P >= min_p, - F.PID_MU >= min_pidmu, + F.conditionally_skip(F.PID_MU >= min_pidmu, label="PID"), in_range(min_ip, F.MINIP(pvs), max_ip), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/qee_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/qee_builders.py index 49db78948d7..08b88cb772c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/qee_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/qee_builders.py @@ -83,7 +83,7 @@ def make_qee_has_rich_detached_pions( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K <= 0.0), + pid=F.conditionally_skip((F.PID_K <= 0.0), label="PID"), ): """ Return QEE detached pions with hasRich. @@ -104,7 +104,7 @@ def make_qee_has_rich_detached_kaons( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): """ Return QEE detached kaons with hasRich. @@ -125,7 +125,7 @@ def make_qee_detached_muons( pt_min=250.0 * MeV, p_min=3000.0 * MeV, mipchi2dvprimary_min=3.0, - pid=F.require_all(F.ISMUON, F.PID_MU > 0.0), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 0.0, label="PID")), ): """ Return QEE detached muons. @@ -146,7 +146,7 @@ def make_qee_detached_kaons( name="qee_detached_kaons_{hash}", p_min=2.0 * GeV, pt_min=250.0 * MeV, - pid=(F.PID_K > -2.0), + pid=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): """ Return QEE detached kaons. @@ -167,7 +167,7 @@ def make_qee_detached_pions( pt_min, name="qee_detached_pions_{hash}", mipchi2dvprimary_min=25.0, - pid=(F.PID_K <= 1e-5), + pid=F.conditionally_skip((F.PID_K <= 1e-5), label="PID"), ): """ Return QEE detached pions. @@ -193,8 +193,8 @@ def make_qee_detached_kstar0s( # if the RICH can not distinguish between kaons and pions then # the PID will be set to zero, and most often these will correspond # to real pions - pi_pid=F.PID_K < 1e-5, - k_pid=(F.PID_K > 2.0), + pi_pid=F.conditionally_skip(F.PID_K < 1e-5, label="PID"), + k_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), kstar0_pt_min=400.0 * MeV, adocachi2cut=30.0, maxdoca=500 * micrometer, @@ -249,7 +249,9 @@ def muon_filter(min_pt=0.0 * GeV, require_muID=True): @configurable def elec_filter(min_pt=0.0 * GeV, min_electron_id=-1): # An electron filter: PT - code = F.require_all(F.PT > min_pt, F.PID_E > min_electron_id) + code = F.require_all( + F.PT > min_pt, F.conditionally_skip(F.PID_E > min_electron_id, label="PID") + ) particles = make_long_electrons_with_brem() return ParticleFilter(particles, F.FILTER(code)) @@ -259,7 +261,9 @@ def elec_filter(min_pt=0.0 * GeV, min_electron_id=-1): def elec_filter_down(min_pt=0.0 * GeV, min_electron_id=-1): # An down type electron filter: PT - code = F.require_all(F.PT > min_pt, F.PID_E > min_electron_id) + code = F.require_all( + F.PT > min_pt, F.conditionally_skip(F.PID_E > min_electron_id, label="PID") + ) particles = make_down_electrons_no_brem() return ParticleFilter(particles, F.FILTER(code)) @@ -421,14 +425,14 @@ def filter_ttrack_muons_for_high_mass( F.P > p_min, F.NFTHITS @ F.TRACK > track_min, F.CHI2 < chi2_max, - F.PID_MU > pid_mu_min, + F.conditionally_skip(F.PID_MU > pid_mu_min, label="PID"), F.ISMUON, F.MINIPCHI2(pvs) > minipchi2_min, ) if pid_mu_diff_max is not None: filter_code_high_mass &= F.require_all( - (F.PID_K - F.PID_MU) < pid_mu_diff_max, - (F.PID_P - F.PID_MU) < pid_mu_diff_max, + F.conditionally_skip((F.PID_K - F.PID_MU) < pid_mu_diff_max, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_MU) < pid_mu_diff_max, label="PID"), ) if hcalo_mu_min is not None: filter_code_high_mass &= F.require_all(F.HCALPIDMU > hcalo_mu_min) @@ -459,10 +463,10 @@ def filter_ttrack_kaons_for_high_mass( F.GHOSTPROB < ghostprob_max, F.NFTHITS @ F.TRACK > track_min, F.math.in_range(pid_k_min, F.PID_K, pid_k_max), - F.PID_P < pid_p_max, - F.PID_MU < pid_mu_max, + F.conditionally_skip(F.PID_P < pid_p_max, label="PID"), + F.conditionally_skip(F.PID_MU < pid_mu_max, label="PID"), F.CHI2 < chi2_max, - F.PID_MU > pid_mu_min, + F.conditionally_skip(F.PID_MU > pid_mu_min, label="PID"), F.MINIPCHI2(pvs) > minipchi2_min, ) return ParticleFilter(kaons, F.FILTER(filter_code_high_mass)) @@ -489,14 +493,16 @@ def filter_ttrack_pions_for_high_mass( F.P > p_min, F.GHOSTPROB < ghostprob_max, F.NFTHITS @ F.TRACK > track_min, - F.PID_P < pid_p_max, - F.PID_K < pid_k_max, - F.PID_MU < pid_mu_max, + F.conditionally_skip(F.PID_P < pid_p_max, label="PID"), + F.conditionally_skip(F.PID_K < pid_k_max, label="PID"), + F.conditionally_skip(F.PID_MU < pid_mu_max, label="PID"), F.CHI2 < chi2_max, F.MINIPCHI2(pvs) > minipchi2_min, ) if not_ismuon: - filter_code_high_mass &= F.require_all(~F.ISMUON) + filter_code_high_mass &= F.require_all( + F.conditionally_skip(~F.ISMUON, label="ISMUON") + ) return ParticleFilter(pions, F.FILTER(filter_code_high_mass)) @@ -519,9 +525,9 @@ def filter_down_muons( F.PT > pt_min, F.P > p_min, F.CHI2 < chi2_max, - F.PID_MU > pid_mu_min, - F.PID_K < pid_k_max, - F.PID_P < pid_p_max, + F.conditionally_skip(F.PID_MU > pid_mu_min, label="PID"), + F.conditionally_skip(F.PID_K < pid_k_max, label="PID"), + F.conditionally_skip(F.PID_P < pid_p_max, label="PID"), F.ISMUON, F.OWNPVIPCHI2 > minipchi2_min, ) @@ -679,7 +685,7 @@ def make_majorana_long_muon(pvs): leptons=make_long_muons, pvs=pvs, name="majo_long_muons_{hash}", - pid=F.require_all(F.ISMUON, F.PID_MU > 2), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 2, label="PID")), ) @@ -689,7 +695,7 @@ def make_majorana_down_muon(pvs): pvs=pvs, name="majo_down_muons_{hash}", mipchi2dvprimary_min=0.0, - pid=F.require_all(F.ISMUON, F.PID_MU > 2), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 2, label="PID")), ) @@ -698,7 +704,10 @@ def make_majorana_long_pion(pvs): leptons=make_long_pions, pvs=pvs, name="majo_long_pions_{hash}", - pid=F.require_all(F.PID_E <= 0.0, F.PID_MU <= 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_E <= 0.0, label="PID"), + F.conditionally_skip(F.PID_MU <= 0.0, label="PID"), + ), ) @@ -708,7 +717,10 @@ def make_majorana_down_pion(pvs): pvs=pvs, name="majo_down_pions_{hash}", mipchi2dvprimary_min=0.0, - pid=F.require_all(F.PID_E <= 0.0, F.PID_MU <= 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_E <= 0.0, label="PID"), + F.conditionally_skip(F.PID_MU <= 0.0, label="PID"), + ), ) @@ -717,7 +729,7 @@ def make_majorana_long_electron(pvs): leptons=make_long_electrons_with_brem, pvs=pvs, name="majo_long_electrons_with_brem_{hash}", - pid=(F.PID_E > 1.0), + pid=F.conditionally_skip((F.PID_E > 1.0), label="PID"), ) @@ -727,7 +739,7 @@ def make_majorana_down_electron(pvs): pvs=pvs, name="majo_down_electrons_without_brem_{hash}", mipchi2dvprimary_min=0.0, - pid=(F.PID_E > 1.0), + pid=F.conditionally_skip((F.PID_E > 1.0), label="PID"), ) @@ -851,15 +863,17 @@ def make_tt_electrons_for_hnl( F.P > p_min, F.NFTHITS @ F.TRACK > track_min, F.CHI2 < chi2_max, - F.PID_E > pid_e_min, - F.PID_MU < pid_mu_max, - F.PID_K < pid_k_max, - F.PID_P < pid_p_max, + F.conditionally_skip(F.PID_E > pid_e_min, label="PID"), + F.conditionally_skip(F.PID_MU < pid_mu_max, label="PID"), + F.conditionally_skip(F.PID_K < pid_k_max, label="PID"), + F.conditionally_skip(F.PID_P < pid_p_max, label="PID"), F.MINIPCHI2(pvs) > minipchi2_min, ) if not_ismuon: - filter_code_high_mass &= F.require_all(~F.ISMUON) + filter_code_high_mass &= F.require_all( + F.conditionally_skip(~F.ISMUON, label="ISMUON") + ) return ParticleFilter(electrons, F.FILTER(filter_code_high_mass)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/quarkonia.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/quarkonia.py index 38b3f9ab32e..85a1205f88f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/quarkonia.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/quarkonia.py @@ -47,7 +47,7 @@ def make_muons( muons = make_ismuon_long_muon() code = F.require_all(F.PT > min_pT, F.ISMUON, F.CHI2DOF < max_trchi2dof) if min_pidmu_muon is not None: - code &= F.PID_MU > min_pidmu_muon + code &= F.conditionally_skip(F.PID_MU > min_pidmu_muon, label="PID") return ParticleFilter(muons, name=name, Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/sexaquark.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/sexaquark.py index 962b65492ae..fd7eda8083f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/sexaquark.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/sexaquark.py @@ -90,7 +90,7 @@ def make_displaced_pion(is_down=False): @configurable def make_displaced_kaon(is_down=False): - code = F.PID_K > min_pid_k + code = F.conditionally_skip(F.PID_K > min_pid_k, label="PID") kaon = make_has_rich_down_kaons() if is_down else make_has_rich_long_kaons() return ParticleFilter(make_displaced_track(kaon), F.FILTER(code)) @@ -138,7 +138,7 @@ def make_displaced_L(is_down=False): pvs = make_pvs() code = F.require_all( F.CHILD(1, F.MINIPCHI2(pvs)) > minipchi2, # For proton only - F.CHILD(1, F.PROBNN_P) > min_prob_p, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > min_prob_p, label="PROBNN"), F.CHILD(1, F.OWNPVIP) > (minip_down if is_down else minip), F.CHILD(2, F.OWNPVIP) > (minip_down if is_down else minip), ) @@ -214,7 +214,9 @@ def make_sexaquark( # First child: if descriptor == "[p+ -> K+ K+ pi-]cc": # 2 charged kaons - composite_cut &= F.CHILD(1, F.PROBNN_K) > min_prob_k + composite_cut &= F.conditionally_skip( + F.CHILD(1, F.PROBNN_K) > min_prob_k, label="PROBNN" + ) else: # 1 or 2 composite daughter particles composite_cut &= _DZ_CHILD(1) > DZ1 @@ -226,7 +228,9 @@ def make_sexaquark( ]: # 2 composite daughter particles composite_cut &= _DZ_CHILD(2) > DZ2 else: # 1 or 2 charged kaons - composite_cut &= F.CHILD(2, F.PROBNN_K) > min_prob_k + composite_cut &= F.conditionally_skip( + F.CHILD(2, F.PROBNN_K) > min_prob_k, label="PROBNN" + ) if min_dls is not None: composite_cut &= F.OWNPVDLS > min_dls diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/single_high_pt_electron.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/single_high_pt_electron.py index f6ace2dcdcd..5377b0c7098 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/single_high_pt_electron.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/single_high_pt_electron.py @@ -46,7 +46,7 @@ def make_highpt_electrons( ): code = F.require_all( F.PT > min_electron_pt, - F.PID_E > min_electron_id, + F.conditionally_skip(F.PID_E > min_electron_id, label="PID"), F.ELECTRONSHOWEREOP > ecal_deposit_fraction, F.HCALEOP < hcal_deposit_fraction, ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/spruce_qee.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/spruce_qee.py index 5a9c8e285d7..a128868f10e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/spruce_qee.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/spruce_qee.py @@ -1199,7 +1199,7 @@ def qee_BtoKH_MuMu_exclTT( ): pvs = make_pvs() filtered_long_kaons = make_qee_detached_kaons( - pid=(F.PID_K > 3.0), mipchi2dvprimary_min=4.0 + pid=F.conditionally_skip((F.PID_K > 3.0), label="PID"), mipchi2dvprimary_min=4.0 ) dimuon = get_particles( h_to_mumu_dimuon_path() @@ -1225,7 +1225,9 @@ def qee_BtoKstar0H_MuMu_exclTT( name="SpruceQEE_BtoKstar0H_MuMu_exclTT", prescale=1.0, stream=qee_stream_split.low ): pvs = make_pvs() - long_kstars = make_qee_detached_kstar0s(k_pid=(F.PID_K > 5.0)) + long_kstars = make_qee_detached_kstar0s( + k_pid=F.conditionally_skip((F.PID_K > 5.0), label="PID") + ) dimuon = get_particles( h_to_mumu_dimuon_path() ) # no fitted T tracks in persist_reco diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/wz_boson_rare_decays.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/wz_boson_rare_decays.py index ad5755c9f42..a671a117bdc 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/wz_boson_rare_decays.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/qee/wz_boson_rare_decays.py @@ -42,7 +42,10 @@ _default_monitoring_variables = ("pt", "eta", "n_candidates", "ipchi2", "vchi2") @configurable def make_EW_pions(pvs, p_min=1 * GeV, min_pt=1 * GeV, p_pidk_max=5.0, mipchi2_min=0): code = F.require_all( - F.P > p_min, F.PT > min_pt, F.PID_K < p_pidk_max, F.MINIPCHI2(pvs) > mipchi2_min + F.P > p_min, + F.PT > min_pt, + F.conditionally_skip(F.PID_K < p_pidk_max, label="PID"), + F.MINIPCHI2(pvs) > mipchi2_min, ) particles = make_has_rich_long_pions() @@ -52,7 +55,10 @@ def make_EW_pions(pvs, p_min=1 * GeV, min_pt=1 * GeV, p_pidk_max=5.0, mipchi2_mi @configurable def make_EW_kaons(pvs, p_min=1 * GeV, min_pt=1 * GeV, p_pidk_min=-5, mipchi2_min=0): code = F.require_all( - F.P > p_min, F.PT > min_pt, F.PID_K > p_pidk_min, F.MINIPCHI2(pvs) > mipchi2_min + F.P > p_min, + F.PT > min_pt, + F.conditionally_skip(F.PID_K > p_pidk_min, label="PID"), + F.MINIPCHI2(pvs) > mipchi2_min, ) particles = make_has_rich_long_kaons() @@ -62,7 +68,10 @@ def make_EW_kaons(pvs, p_min=1 * GeV, min_pt=1 * GeV, p_pidk_min=-5, mipchi2_min @configurable def make_EW_protons(pvs, p_min=1 * GeV, min_pt=1 * GeV, p_pidp_min=-5, mipchi2_min=0): code = F.require_all( - F.P > p_min, F.PT > min_pt, F.PID_P > p_pidp_min, F.MINIPCHI2(pvs) > mipchi2_min + F.P > p_min, + F.PT > min_pt, + F.conditionally_skip(F.PID_P > p_pidp_min, label="PID"), + F.MINIPCHI2(pvs) > mipchi2_min, ) particles = make_has_rich_long_protons() diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu.py index 4a6c446e25c..e71118ee023 100755 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu.py @@ -44,11 +44,13 @@ all_lines = {} @configurable def butokemu_line(name="Hlt2RD_BuToKpEMu", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2.0), label="PID") ) dileptons = b_to_hemu_builders.make_dilepton( muons, electrons, "[J/psi(1S) -> mu+ e-]cc" @@ -70,7 +72,9 @@ def butokemu_line(name="Hlt2RD_BuToKpEMu", prescale=1): @configurable def butopiemu_line(name="Hlt2RD_BuToPipEMu", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) pions = rdbuilder_thor.make_rd_has_rich_detached_pions(mipchi2dvprimary_min=9) @@ -94,11 +98,13 @@ def butopiemu_line(name="Hlt2RD_BuToPipEMu", prescale=1): @configurable def bstophiemu_line(name="Hlt2RD_BsToPhiEMu_PhiToKK", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2.0), label="PID") ) dileptons = b_to_hemu_builders.make_dilepton( muons, electrons, "[J/psi(1S) -> mu+ e-]cc" @@ -130,11 +136,13 @@ def bstophiemu_line(name="Hlt2RD_BsToPhiEMu_PhiToKK", prescale=1): @configurable def bdtokstemu_line(name="Hlt2RD_BdToKstEMu_KstToKpPim", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2.0), label="PID") ) pions = rdbuilder_thor.make_rd_has_rich_detached_pions(mipchi2dvprimary_min=9) dileptons = b_to_hemu_builders.make_dilepton( @@ -160,18 +168,23 @@ def bdtokstemu_line(name="Hlt2RD_BdToKstEMu_KstToKpPim", prescale=1): @configurable def lbtopkemu_line(name="Hlt2RD_LbToPKEMu", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) dileptons = b_to_hemu_builders.make_dilepton( muons, electrons, "[J/psi(1S) -> mu+ e-]cc" ) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) protons = rdbuilder_thor.make_rd_has_rich_detached_protons( mipchi2dvprimary_min=9, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 2.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 2.0, label="PID"), + ), ) dihadron = b_to_hemu_builders.make_hh( protons, @@ -200,11 +213,13 @@ def lbtopkemu_line(name="Hlt2RD_LbToPKEMu", prescale=1): @configurable def butokemuSS_line(name="Hlt2RD_BuToKpEMu_SameSign", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2.0), label="PID") ) dileptons = b_to_hemu_builders.make_dilepton( muons, electrons, "[J/psi(1S) -> mu+ e+]cc" @@ -226,7 +241,9 @@ def butokemuSS_line(name="Hlt2RD_BuToKpEMu_SameSign", prescale=1): @configurable def butopiemuSS_line(name="Hlt2RD_BuToPipEMu_SameSign", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) pions = rdbuilder_thor.make_rd_has_rich_detached_pions(mipchi2dvprimary_min=9) @@ -250,11 +267,13 @@ def butopiemuSS_line(name="Hlt2RD_BuToPipEMu_SameSign", prescale=1): @configurable def bstophiemuSS_line(name="Hlt2RD_BsToPhiEMu_SameSign_PhiToKK", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2.0), label="PID") ) dileptons = b_to_hemu_builders.make_dilepton( muons, electrons, "[J/psi(1S) -> mu+ e+]cc" @@ -286,11 +305,13 @@ def bstophiemuSS_line(name="Hlt2RD_BsToPhiEMu_SameSign_PhiToKK", prescale=1): @configurable def bdtokstemuSS_line(name="Hlt2RD_BdToKstEMu_SameSign_KstToKpPim", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2.0), label="PID") ) pions = rdbuilder_thor.make_rd_has_rich_detached_pions(mipchi2dvprimary_min=9) dileptons = b_to_hemu_builders.make_dilepton( @@ -316,18 +337,23 @@ def bdtokstemuSS_line(name="Hlt2RD_BdToKstEMu_SameSign_KstToKpPim", prescale=1): @configurable def lbtopkemuSS_line(name="Hlt2RD_LbToPKEMu_SameSign", prescale=1): electrons = rdbuilder_thor.make_rd_detached_electrons( - pt_min=500.0 * MeV, mipchi2dvprimary_min=12, pid=(F.PID_E > 2.0) + pt_min=500.0 * MeV, + mipchi2dvprimary_min=12, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) muons = rdbuilder_thor.make_rd_detached_muons(mipchi2dvprimary_min=9) dileptons = b_to_hemu_builders.make_dilepton( muons, electrons, "[J/psi(1S) -> mu+ e+]cc" ) kaons = rdbuilder_thor.make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) protons = rdbuilder_thor.make_rd_has_rich_detached_protons( mipchi2dvprimary_min=9, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 2.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 2.0, label="PID"), + ), ) dihadron = b_to_hemu_builders.make_hh( protons, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu_control_modes.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu_control_modes.py index 1238afcdae6..abbe88a4a7e 100755 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu_control_modes.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_hemu_control_modes.py @@ -81,7 +81,7 @@ RD_B_TO_LL_PERSIST_OBJECTS = [ @configurable def butokjpsi_mumu_line(name="Hlt2RD_BuToKpJpsi_JpsiToMuMu", prescale=1): kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) dileptons = rdbuilder_thor.make_rd_detached_dimuon(am_max=5500 * MeV) bu = b_to_hemu_builders.make_btohemu(kaons, dileptons, "[B+ -> J/psi(1S) K+]cc") @@ -120,7 +120,7 @@ def butopijpsi_mumu_line(name="Hlt2RD_BuToPipJpsi_JpsiToMuMu", prescale=1): @configurable def bstophijpsi_mumu_line(name="Hlt2RD_BsToPhiJpsi_PhiToKK_JpsiToMuMu", prescale=1): kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) dileptons = rdbuilder_thor.make_rd_detached_dimuon(am_max=5500 * MeV) dikaons = b_to_hemu_builders.make_hh( @@ -153,7 +153,7 @@ def bstophijpsi_mumu_line(name="Hlt2RD_BsToPhiJpsi_PhiToKK_JpsiToMuMu", prescale @configurable def bdtokstjpsi_mumu_line(name="Hlt2RD_BdToKstJpsi_KstToKpPim_JpsiToMuMu", prescale=1): kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) pions = rdbuilder_thor.make_rd_detached_pions(mipchi2dvprimary_min=9) dileptons = rdbuilder_thor.make_rd_detached_dimuon(am_max=5500 * MeV) @@ -181,11 +181,14 @@ def bdtokstjpsi_mumu_line(name="Hlt2RD_BdToKstJpsi_KstToKpPim_JpsiToMuMu", presc def lbtopkjpsi_mumu_line(name="Hlt2RD_LbToPKJpsi_JpsiToMuMu", prescale=1): dileptons = rdbuilder_thor.make_rd_detached_dimuon(am_max=5500 * MeV) kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) protons = rdbuilder_thor.make_rd_detached_protons( mipchi2dvprimary_min=9, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), + ), ) dihadron = b_to_hemu_builders.make_hh( protons, @@ -212,7 +215,7 @@ def lbtopkjpsi_mumu_line(name="Hlt2RD_LbToPKJpsi_JpsiToMuMu", prescale=1): @configurable def butokjpsi_ee_line(name="Hlt2RD_BuToKpJpsi_JpsiToEE", prescale=1): kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) dileptons = rdbuilder_thor.make_rd_detached_dielectron( ipchi2_e_min=12.0, @@ -264,7 +267,7 @@ def butopijpsi_ee_line(name="Hlt2RD_BuToPipJpsi_JpsiToEE", prescale=1): @configurable def bstophijpsi_ee_line(name="Hlt2RD_BsToPhiJpsi_PhiToKK_JpsiToEE", prescale=1): kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) dileptons = rdbuilder_thor.make_rd_detached_dielectron( ipchi2_e_min=12.0, @@ -306,7 +309,7 @@ def bstophijpsi_ee_line(name="Hlt2RD_BsToPhiJpsi_PhiToKK_JpsiToEE", prescale=1): @configurable def bdtokstjpsi_ee_line(name="Hlt2RD_BdToKstJpsi_KstToKpPim_JpsiToEE", prescale=1): kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) pions = rdbuilder_thor.make_rd_detached_pions(mipchi2dvprimary_min=9) dileptons = rdbuilder_thor.make_rd_detached_dielectron( @@ -350,11 +353,14 @@ def lbtopkjpsi_ee_line(name="Hlt2RD_LbToPKJpsi_JpsiToEE", prescale=1): am_max=5500 * MeV, ) kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9, pid=(F.PID_K > 2) + mipchi2dvprimary_min=9, pid=F.conditionally_skip((F.PID_K > 2), label="PID") ) protons = rdbuilder_thor.make_rd_detached_protons( mipchi2dvprimary_min=9, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), + ), ) dihadron = b_to_hemu_builders.make_hh( protons, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_multilepton_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_multilepton_hlt2.py index f1c621918f7..df830c74b4c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_multilepton_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_multilepton_hlt2.py @@ -66,7 +66,8 @@ def Displaced4Mu_incl_line( """ lepton = make_rd_detached_muons( - pid=F.require_all(F.PID_MU > 0, F.ISMUON), mipchi2dvprimary_min=16 + pid=F.require_all(F.conditionally_skip(F.PID_MU > 0, label="PID"), F.ISMUON), + mipchi2dvprimary_min=16, ) b = make_rd_b_to_multilepton( @@ -105,7 +106,9 @@ def Displaced4E_incl_line(name="Hlt2RD_Displaced4E_Incl", prescale=1, persistrec Displaced->4e inclusive selection, bremsstrahlung check needs to be done offline """ - lepton = make_rd_detached_electrons(pid=(F.PID_E > 1), mipchi2dvprimary_min=16) + lepton = make_rd_detached_electrons( + pid=F.conditionally_skip((F.PID_E > 1), label="PID"), mipchi2dvprimary_min=16 + ) b = make_rd_b_to_multilepton( inputs=[lepton, lepton, lepton, lepton], descriptor="B0 -> e+ e+ e- e-", @@ -261,7 +264,10 @@ def BuTo2LLPKp_LLPToMuMu_LL_line( ): """B+ -> X (mumu) X (mumu) K+ with long muon combinations""" dimuon = make_rd_detached_dimuon(parent_id="KS0", pidmu_muon_min=0) - kaon = make_rd_detached_kaons(pid=(F.PID_K > 0.0), mipchi2dvprimary_min=25.0) + kaon = make_rd_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), + mipchi2dvprimary_min=25.0, + ) b = make_rd_b_to_multilepton_LLP( inputs=[dimuon, dimuon, kaon], descriptor="[B+ -> KS0 KS0 K+]cc", @@ -290,7 +296,7 @@ def BuTo2LLPKp_LLPToMuMu_DD_line( ipchi2_muon_min=20.0, ) kaon = make_rd_detached_down_kaons( - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), mipchi2dvprimary_min=25.0, ) b = make_rd_b_to_multilepton_LLP( @@ -316,7 +322,10 @@ def BuTo2LLPKp_LLPToEE_LL_line( dielectron = make_rd_detached_dielectron( parent_id="KS0", pid_e_min=1, am_min=10.0 * MeV ) - kaon = make_rd_detached_kaons(pid=(F.PID_K > 0.0), mipchi2dvprimary_min=25.0) + kaon = make_rd_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), + mipchi2dvprimary_min=25.0, + ) b = make_rd_b_to_multilepton_LLP( inputs=[dielectron, dielectron, kaon], descriptor="[B+ -> KS0 KS0 K+]cc", @@ -391,7 +400,10 @@ def BuTo3LLPKp_LLPToMuMu_LLL_line( dimuons = make_rd_detached_dimuon( parent_id="KS0", pidmu_muon_min=0, pt_muon_min=150 * MeV ) - kaon = make_rd_detached_kaons(pid=(F.PID_K > 0.0), mipchi2dvprimary_min=16.0) + kaon = make_rd_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), + mipchi2dvprimary_min=16.0, + ) b = make_rd_b_to_multilepton_LLP( inputs=[dimuons, dimuons, dimuons, kaon], descriptor="[B+ -> KS0 KS0 KS0 K+]cc", @@ -415,7 +427,10 @@ def BuTo3LLPKp_LLPToEE_LLL_line( dielectron = make_rd_detached_dielectron( parent_id="KS0", pid_e_min=1, am_min=10.0 * MeV ) - kaon = make_rd_detached_kaons(pid=(F.PID_K > 0.0), mipchi2dvprimary_min=25.0) + kaon = make_rd_detached_kaons( + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), + mipchi2dvprimary_min=25.0, + ) b = make_rd_b_to_multilepton_LLP( inputs=[dielectron, dielectron, dielectron, kaon], descriptor="[B+ -> KS0 KS0 KS0 K+]cc", diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2.py index 2728dd6d8ba..f7b150006a2 100755 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2.py @@ -107,7 +107,7 @@ BtoKee = { "pt_min": 400.0 * MeV, "mipchi2dvprimary_min": 9.0, "p_min": 0.0 * MeV, - "pid": (F.PID_K > -4.0), + "pid": F.conditionally_skip((F.PID_K > -4.0), label="PID"), }, } @@ -208,7 +208,7 @@ Btopiee = { "pt_min": 400.0 * MeV, "mipchi2dvprimary_min": 9.0, "p_min": 0.0 * MeV, - "pid": (F.PID_K <= 4.0), + "pid": F.conditionally_skip((F.PID_K <= 4.0), label="PID"), }, } @@ -468,7 +468,7 @@ def make_rd_detached_kaons_for_hPi0ll( pt_min=pt_kaon_min, p_min=p_kaon_min, mipchi2dvprimary_min=mipchi2dvprimary_min, - pid=(F.PID_K > pid_k_min), + pid=F.conditionally_skip((F.PID_K > pid_k_min), label="PID"), ) @@ -482,7 +482,7 @@ def make_rd_detached_pions_for_hPi0ll( pt_min=pt_pion_min, p_min=p_pion_min, mipchi2dvprimary_min=mipchi2dvprimary_min, - pid=(F.PID_K < pid_k_max), + pid=F.conditionally_skip((F.PID_K < pid_k_max), label="PID"), ) @@ -1063,7 +1063,7 @@ BtoKKee = { "acceptance_cut": True, }, "phis": { - "k_pid": (F.PID_K > 0.0), + "k_pid": F.conditionally_skip((F.PID_K > 0.0), label="PID"), "am_min": 0.0 * MeV, "am_max": 1100.0 * MeV, "k_p_min": 0.0 * MeV, @@ -1098,7 +1098,7 @@ BtoKKmumu = { "am_max": 5_500.0 * MeV, }, "phis": { - "k_pid": (F.PID_K > -4.0), + "k_pid": F.conditionally_skip((F.PID_K > -4.0), label="PID"), "am_min": 0.0 * MeV, "am_max": 1100.0 * MeV, "k_p_min": 0.0 * MeV, @@ -1893,7 +1893,7 @@ def BToPpPmEE_line(name="Hlt2RD_BToPpPmEE", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1937,7 +1937,7 @@ def BToPpPmEE_SameSign_line(name="Hlt2RD_BToPpPmEESS", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1981,7 +1981,7 @@ def BuToL0PmEE_LL_line(name="Hlt2RD_BuToL0PmEE_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2026,7 +2026,7 @@ def BuToL0PmEE_LL_SameSign_line(name="Hlt2RD_BuToL0PmEESS_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2069,7 +2069,7 @@ def BuToL0PmEE_DD_line(name="Hlt2RD_BuToL0PmEE_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2113,7 +2113,7 @@ def BuToL0PmEE_DD_SameSign_line(name="Hlt2RD_BuToL0PmEESS_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2149,7 +2149,7 @@ def BToPpPmMuMu_line(name="Hlt2RD_BToPpPmMuMu", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2184,7 +2184,7 @@ def BToPpPmMuMu_SameSign_line(name="Hlt2RD_BToPpPmMuMuSS", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2220,7 +2220,7 @@ def BuToL0PmMuMu_LL_line(name="Hlt2RD_BuToL0PmMuMu_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2255,7 +2255,7 @@ def BuToL0PmMuMu_LL_SameSign_line(name="Hlt2RD_BuToL0PmMuMuSS_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2290,7 +2290,7 @@ def BuToL0PmMuMu_DD_line(name="Hlt2RD_BuToL0PmMuMu_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -2325,7 +2325,7 @@ def BuToL0PmMuMu_DD_SameSign_line(name="Hlt2RD_BuToL0PmMuMuSS_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2_mva.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2_mva.py index 3c106c4b96d..218000c5a0b 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2_mva.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_hlt2_mva.py @@ -176,7 +176,7 @@ class llx_mva_options: d_opt["pt_min"] = 250.0 * MeV d_opt["mipchi2dvprimary_min"] = 9.0 d_opt["p_min"] = 0.0 * GeV - d_opt["pid"] = F.PID_K > -2.0 + d_opt["pid"] = F.conditionally_skip(F.PID_K > -2.0, label="PID") return d_opt @@ -190,11 +190,11 @@ class llx_mva_options: d_opt["pi_p_min"] = 2.0 * GeV d_opt["pi_pt_min"] = 250.0 * MeV d_opt["pi_ipchi2_min"] = 9.0 - d_opt["pi_pid"] = F.PID_K < 1e-5 + d_opt["pi_pid"] = F.conditionally_skip(F.PID_K < 1e-5, label="PID") d_opt["k_p_min"] = 2.0 * GeV d_opt["k_pt_min"] = 250.0 * MeV d_opt["k_ipchi2_min"] = 9.0 - d_opt["k_pid"] = F.PID_K > 0.0 + d_opt["k_pid"] = F.conditionally_skip(F.PID_K > 0.0, label="PID") d_opt["kstar0_pt_min"] = 0.0 * MeV d_opt["adocachi2cut"] = 30.0 d_opt["vchi2pdof_max"] = 16.0 @@ -228,7 +228,7 @@ class llx_mva_options: d_opt["k_p_min"] = 0.0 * GeV d_opt["k_pt_min"] = 200.0 * MeV d_opt["k_ipchi2_min"] = 9.0 - d_opt["k_pid"] = F.PID_K > 0.0 + d_opt["k_pid"] = F.conditionally_skip(F.PID_K > 0.0, label="PID") return d_opt @@ -365,7 +365,9 @@ def filter_dileptons(dilepton, ghst_prob=0.5, trchi2dof_max=3.0): # ---------------------------- def tag_dielectron_pid(dielectrons, pid_tag=4.0): - code = (F.CHILD(1, F.PID_E) > pid_tag) | (F.CHILD(2, F.PID_E) > pid_tag) + code = F.conditionally_skip( + (F.CHILD(1, F.PID_E) > pid_tag), label="PID" + ) | F.conditionally_skip((F.CHILD(2, F.PID_E) > pid_tag), label="PID") flt = ParticleFilter(dielectrons, Cut=F.FILTER(code)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_spruce.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_spruce.py index b8a8a721a02..aa146f22619 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_spruce.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xll_spruce.py @@ -1247,7 +1247,9 @@ def Spruce_BuToKpMuE_line(name="SpruceRD_BuToKpMuE", prescale=1): same_sign=False, max_vchi2ndof=9.0 ) kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9.0, pid=(F.PID_K > 0.0), pt_min=400.0 * MeV + mipchi2dvprimary_min=9.0, + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), + pt_min=400.0 * MeV, ) Bu = b_to_xll_builders.make_rd_BToXll( @@ -1278,8 +1280,8 @@ def Spruce_B0ToKpPimMuE_line(name="SpruceRD_B0ToKpPimMuE", prescale=1): hadron = rdbuilder_thor.make_rd_detached_kstar0s( am_min=500 * MeV, am_max=2600 * MeV, - pi_pid=(F.PID_K < -0.0), ##new - k_pid=(F.PID_K > 0.0), + pi_pid=F.conditionally_skip((F.PID_K < -0.0), label="PID"), ##new + k_pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), pi_ipchi2_min=9.0, k_ipchi2_min=9.0, pi_pt_min=250 * MeV, @@ -1316,7 +1318,9 @@ def Spruce_BuToKpMuE_SameSignMuE_line( same_sign=True, max_vchi2ndof=9.0 ) kaons = rdbuilder_thor.make_rd_detached_kaons( - mipchi2dvprimary_min=9.0, pid=(F.PID_K > 0.0), pt_min=400.0 * MeV + mipchi2dvprimary_min=9.0, + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), + pt_min=400.0 * MeV, ) Bu = b_to_xll_builders.make_rd_BToXll( @@ -1349,8 +1353,8 @@ def Spruce_B0ToKpPimMuE_SameSignMuE_line( hadron = rdbuilder_thor.make_rd_detached_kstar0s( am_min=500 * MeV, am_max=2600 * MeV, - pi_pid=(F.PID_K < -0.0), ##new - k_pid=(F.PID_K > 0.0), + pi_pid=F.conditionally_skip((F.PID_K < -0.0), label="PID"), ##new + k_pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), pi_ipchi2_min=9.0, k_ipchi2_min=9.0, pi_pt_min=250 * MeV, @@ -1389,7 +1393,7 @@ def BToPpPmEE_line(name="SpruceRD_BToPpPmEE", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1423,7 +1427,7 @@ def BToPpPmEE_SameSign_line(name="SpruceRD_BToPpPmEESS", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1455,7 +1459,7 @@ def BuToL0PmEE_LL_line(name="SpruceRD_BuToL0PmEE_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 1.0), + pid=F.conditionally_skip((F.PID_P > 1.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1490,7 +1494,7 @@ def BuToL0PmEE_LL_SameSign_line(name="SpruceRD_BuToL0PmEESS_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 1.0), + pid=F.conditionally_skip((F.PID_P > 1.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1526,7 +1530,7 @@ def BuToL0PmEE_DD_line(name="SpruceRD_BuToL0PmEE_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 1.0), + pid=F.conditionally_skip((F.PID_P > 1.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1563,7 +1567,7 @@ def BuToL0PmEE_DD_SameSign_line(name="SpruceRD_BuToL0PmEESS_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 1.0), + pid=F.conditionally_skip((F.PID_P > 1.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1591,7 +1595,7 @@ def BToPpPmMuMu_line(name="SpruceRD_BToPpPmMuMu", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1618,7 +1622,7 @@ def BToPpPmMuMu_SameSign_line(name="SpruceRD_BToPpPmMuMuSS", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bs = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1646,7 +1650,7 @@ def BuToL0PmMuMu_LL_line(name="SpruceRD_BuToL0PmMuMu_LL", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1673,7 +1677,7 @@ def BuToL0PmMuMu_LL_SameSign_line(name="SpruceRD_BuToL0PmMuMuSS_LL", prescale=1) p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1700,7 +1704,7 @@ def BuToL0PmMuMu_DD_line(name="SpruceRD_BuToL0PmMuMu_DD", prescale=1): p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( @@ -1727,7 +1731,7 @@ def BuToL0PmMuMu_DD_SameSign_line(name="SpruceRD_BuToL0PmMuMuSS_DD", prescale=1) p_min=5000.0 * MeV, pt_min=300.0 * MeV, mipchi2dvprimary_min=9, - pid=(F.PID_P > 0.0), + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ) Bu = b_to_xll_builders.make_b_to_Xpbar_dilepton( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xtaul_3pi_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xtaul_3pi_hlt2.py index 2d18f9872b2..466672042fe 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xtaul_3pi_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/b_to_xtaul_3pi_hlt2.py @@ -1653,7 +1653,10 @@ def Hlt2_Bu2KplusTauTau_OS_ExclusiveLine(name="Hlt2RD_BuToKplTauTau_TauTo3Pi_OS" HLT2 line for B+ -> K+ (tau+->pi+pi+pi-) (tau-->pi-pi-pi+) + CC """ kaon = common_builder.make_rd_has_rich_detached_kaons( - pt_min=1 * GeV, p_min=4 * GeV, mipchi2dvprimary_min=9, pid=(F.PID_K > 8) + pt_min=1 * GeV, + p_min=4 * GeV, + mipchi2dvprimary_min=9, + pid=F.conditionally_skip((F.PID_K > 8), label="PID"), ) dilepton = builder.make_dilepton_from_tauls(child_id="tau+") decay_descriptor = "[B+ -> J/psi(1S) K+]cc" @@ -1687,7 +1690,10 @@ def Hlt2_Bu2KplusTauTau_SS_ExclusiveLine(name="Hlt2RD_BuToKplTauTau_TauTo3Pi_SS" and for B+ -> K+ (tau-->pi-pi-pi+) (tau-->pi-pi-pi+) + CC """ kaon = common_builder.make_rd_has_rich_detached_kaons( - pt_min=1 * GeV, p_min=4 * GeV, mipchi2dvprimary_min=9, pid=(F.PID_K > 8) + pt_min=1 * GeV, + p_min=4 * GeV, + mipchi2dvprimary_min=9, + pid=F.conditionally_skip((F.PID_K > 8), label="PID"), ) dilepton = builder.make_dilepton_from_tauls(child_id="tau-") decay_descriptor = "[B+ -> J/psi(1S) K+]cc" @@ -1721,7 +1727,10 @@ def Hlt2_Bu2KplusTauMu_OS_ExclusiveLine(name="Hlt2RD_BuToKplTauMu_TauTo3Pi_OS"): and for B+ -> K+ (tau-->pi-pi-pi+) mu+ + CC """ kaon = common_builder.make_rd_has_rich_detached_kaons( - pt_min=1 * GeV, p_min=4 * GeV, mipchi2dvprimary_min=9, pid=(F.PID_K > 8) + pt_min=1 * GeV, + p_min=4 * GeV, + mipchi2dvprimary_min=9, + pid=F.conditionally_skip((F.PID_K > 8), label="PID"), ) dilepton = builder.make_dilepton_from_tauls(child_id="mu+") decay_descriptor = "[B+ -> J/psi(1S) K+]cc" @@ -1763,7 +1772,10 @@ def Hlt2_Bu2KplusTauMu_SS_ExclusiveLine(name="Hlt2RD_BuToKplTauMu_TauTo3Pi_SS"): and for B+ -> K+ (tau-->pi-pi-pi+) mu- + CC """ kaon = common_builder.make_rd_has_rich_detached_kaons( - pt_min=1 * GeV, p_min=4 * GeV, mipchi2dvprimary_min=9, pid=(F.PID_K > 8) + pt_min=1 * GeV, + p_min=4 * GeV, + mipchi2dvprimary_min=9, + pid=F.conditionally_skip((F.PID_K > 8), label="PID"), ) dilepton = builder.make_dilepton_from_tauls(child_id="mu-") decay_descriptor = "[B+ -> J/psi(1S) K+]cc" @@ -1805,7 +1817,10 @@ def Hlt2_Bu2KplusTauE_OS_ExclusiveLine(name="Hlt2RD_BuToKplTauE_TauTo3Pi_OS"): and for B+ -> K+ (tau-->pi-pi-pi+) e+ + CC """ kaon = common_builder.make_rd_has_rich_detached_kaons( - pt_min=1 * GeV, p_min=4 * GeV, mipchi2dvprimary_min=9, pid=(F.PID_K > 8) + pt_min=1 * GeV, + p_min=4 * GeV, + mipchi2dvprimary_min=9, + pid=F.conditionally_skip((F.PID_K > 8), label="PID"), ) dilepton = builder.make_dilepton_from_tauls(child_id="e+") decay_descriptor = "[B+ -> J/psi(1S) K+]cc" @@ -1849,7 +1864,10 @@ def Hlt2_Bu2KplusTauE_SS_ExclusiveLine(name="Hlt2RD_BuToKplTauE_TauTo3Pi_SS"): and for B+ -> K+ (tau-->pi-pi-pi+) e- + CC """ kaon = common_builder.make_rd_has_rich_detached_kaons( - pt_min=1 * GeV, p_min=4 * GeV, mipchi2dvprimary_min=9, pid=(F.PID_K > 8) + pt_min=1 * GeV, + p_min=4 * GeV, + mipchi2dvprimary_min=9, + pid=F.conditionally_skip((F.PID_K > 8), label="PID"), ) dilepton = builder.make_dilepton_from_tauls(child_id="e-") decay_descriptor = "[B+ -> J/psi(1S) K+]cc" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic.py index c2282413866..be742aacdcd 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic.py @@ -85,7 +85,7 @@ all_lines = {} detached_pions_cuts = { "pt_min": 250 * MeV, "mipchi2dvprimary_min": 4.0, - "pid": (F.PID_K < -1.0), + "pid": F.conditionally_skip((F.PID_K < -1.0), label="PID"), } dimuon_cuts = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic_mva.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic_mva.py index f9a9575c92a..8e86072a656 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic_mva.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/baryonic_mva.py @@ -204,7 +204,10 @@ def Hlt2RD_LbToPpKmPipPimMuMu_MVA(name="Hlt2RD_LbToPpKmPipPimMuMu_MVA", prescale mipchi2dvprimary_min=6.0, pt_min=350.0 * MeV, p_min=9.0 * GeV, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 2.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 2.0, label="PID"), + ), ) # kaon @@ -212,14 +215,14 @@ def Hlt2RD_LbToPpKmPipPimMuMu_MVA(name="Hlt2RD_LbToPpKmPipPimMuMu_MVA", prescale mipchi2dvprimary_min=6.0, pt_min=300.0 * MeV, p_min=3.0 * GeV, - pid=(F.PID_K > 2.0), + pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), ) # dipions dipions = make_dipion_for_lb( pi_pt_min=0.0 * MeV, pi_ipchi2_min=4.0, - pi_pid=(F.PID_K < -1.0), + pi_pid=F.conditionally_skip((F.PID_K < -1.0), label="PID"), pt_min=0.0 * MeV, am_min=250.0 * MeV, am_max=3000.0 * MeV, @@ -273,7 +276,7 @@ def Hlt2RD_LbToPpPimMuMu_MVA(name="Hlt2RD_LbToPpPimMuMu_MVA", prescale=1): pions = make_rd_has_rich_detached_pions( pt_min=250 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K < 0.5), + pid=F.conditionally_skip((F.PID_K < 0.5), label="PID"), ) lb0 = make_bbaryon_3body( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/bnv_lines_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/bnv_lines_hlt2.py index 8b300194c4e..956e74261b3 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/bnv_lines_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/bnv_lines_hlt2.py @@ -84,7 +84,7 @@ def make_tight_rd_detached_muons(): return make_rd_detached_muons( mipchi2dvprimary_min=25.0, # from muon requirement in filter_B2MuMu pt_min=500.0 * MeV, - pid=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID")), ) @@ -102,7 +102,9 @@ def make_tight_rd_detached_protons(): to (F.PID_P > 3) """ return make_rd_detached_protons( - mipchi2dvprimary_min=25.0, pt_min=500.0 * MeV, pid=(F.PID_P > 3) + mipchi2dvprimary_min=25.0, + pt_min=500.0 * MeV, + pid=F.conditionally_skip((F.PID_P > 3), label="PID"), ) @@ -122,7 +124,9 @@ def make_tight_rd_detached_pions(): # TODO: Clarify if this cut really aims to remove the pions that cannot be distinguished from kaons # I doubt it return make_rd_detached_pions( - mipchi2dvprimary_min=25.0, pt_min=500.0 * MeV, pid=(F.PID_K < -2.0) + mipchi2dvprimary_min=25.0, + pt_min=500.0 * MeV, + pid=F.conditionally_skip((F.PID_K < -2.0), label="PID"), ) @@ -140,7 +144,9 @@ def make_tight_rd_detached_kaons(): to (F.PID_K > 3.) """ return make_rd_detached_kaons( - mipchi2dvprimary_min=25.0, pt_min=500.0 * MeV, pid=(F.PID_K > 3.0) + mipchi2dvprimary_min=25.0, + pt_min=500.0 * MeV, + pid=F.conditionally_skip((F.PID_K > 3.0), label="PID"), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btosmutau_exclusive_spruce.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btosmutau_exclusive_spruce.py index f9fbd30cd7e..8f79f58bf01 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btosmutau_exclusive_spruce.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btosmutau_exclusive_spruce.py @@ -77,107 +77,122 @@ kwargs_protons = { "p_min": 3000 * MeV, "pt_min": 250 * MeV, "mipchi2dvprimary_min": 9, - "pid": F.require_all(F.PID_P > 3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { "p_min": 3000 * MeV, "pt_min": 250 * MeV, "mipchi2dvprimary_min": 9, - "pid": (F.PID_P < 3), + "pid": F.conditionally_skip((F.PID_P < 3), label="PID"), } kwargs_kaons = { "pt_min": 250 * MeV, "p_min": 3000 * MeV, "mipchi2dvprimary_min": 9, - "pid": F.require_all(F.PID_K > 3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { "pt_min": 250 * MeV, "p_min": 3000 * MeV, "mipchi2dvprimary_min": 9, - "pid": (F.PID_K < 3), + "pid": F.conditionally_skip((F.PID_K < 3), label="PID"), } kwargs_kaons_for_bu = { "pt_min": 500 * MeV, "p_min": 3000 * MeV, "mipchi2dvprimary_min": 36, - "pid": F.require_all(F.PID_K > 3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_bu_reverse_pid = { "pt_min": 500 * MeV, "p_min": 3000 * MeV, "mipchi2dvprimary_min": 36, - "pid": (F.PID_K < 3), + "pid": F.conditionally_skip((F.PID_K < 3), label="PID"), } kwargs_kaons_for_kstar = { "p_min": 3000 * MeV, "pt_min": 250.0 * MeV, "mipchi2dvprimary_min": 9, - "pid": F.require_all(F.PID_K > 3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { "p_min": 3000 * MeV, "pt_min": 250.0 * MeV, "mipchi2dvprimary_min": 9, - "pid": (F.PID_K < 3), + "pid": F.conditionally_skip((F.PID_K < 3), label="PID"), } kwargs_pions = { "p_min": 0 * MeV, "pt_min": 250 * MeV, "mipchi2dvprimary_min": 9, - "pid": F.require_all(F.PID_K < -2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { "p_min": 0 * MeV, "pt_min": 250 * MeV, "mipchi2dvprimary_min": 9, - "pid": (F.PID_K > -2), + "pid": F.conditionally_skip((F.PID_K > -2), label="PID"), } kwargs_muons_from_tau = { "p_min": 0 * MeV, "pt_min": 0 * MeV, "mipchi2dvprimary_min": 9, - "pid": F.require_all(F.PID_MU > 0, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > 0, label="PID"), F.ISMUON), } kwargs_muons_from_tau_reverse_pid = { "p_min": 0 * MeV, "pt_min": 0 * MeV, "mipchi2dvprimary_min": 9, - "pid": (F.PID_MU < 0), + "pid": F.conditionally_skip((F.PID_MU < 0), label="PID"), } kwargs_muons = { "p_min": 0 * MeV, "mipchi2dvprimary_min": 9, - "pid": F.require_all(F.PID_MU > 0, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > 0, label="PID"), F.ISMUON), "pt_min": 500 * MeV, } kwargs_muons_reverse_pid = { "p_min": 0 * MeV, "mipchi2dvprimary_min": 9, - "pid": (F.PID_MU < 0), + "pid": F.conditionally_skip((F.PID_MU < 0), label="PID"), "pt_min": 500 * MeV, } kwargs_muons_for_bu = { "p_min": 0 * MeV, "mipchi2dvprimary_min": 25, - "pid": F.require_all(F.PID_MU > 0, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > 0, label="PID"), F.ISMUON), "pt_min": 750 * MeV, } kwargs_muons_for_bu_reverse_pid = { "p_min": 0 * MeV, "mipchi2dvprimary_min": 25, - "pid": (F.PID_MU < 0), + "pid": F.conditionally_skip((F.PID_MU < 0), label="PID"), "pt_min": 750 * MeV, } diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_ee_exclusive_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_ee_exclusive_hlt2.py index cc05afcb022..120ae89fee9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_ee_exclusive_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_ee_exclusive_hlt2.py @@ -68,11 +68,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_base = { @@ -82,11 +88,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -96,11 +108,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < 0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > 0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -110,11 +128,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_electrons_base = { @@ -124,11 +148,17 @@ kwargs_electrons_base = { } kwargs_electrons = { **kwargs_electrons_base, - "pid": F.require_all(F.PID_E > 5.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_E > 5.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_electrons_reverse_pid = { **kwargs_electrons_base, - "pid": F.require_all(F.PID_E < 5.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_E < 5.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_bs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_hlt2.py index a573e63d641..1003ff8cd0e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_hlt2.py @@ -71,11 +71,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_base = { @@ -85,11 +91,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 1.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 1.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -99,11 +111,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -113,11 +131,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_muons_base = { @@ -127,11 +151,11 @@ kwargs_muons_base = { } kwargs_muons = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU > -2, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > -2, label="PID"), F.ISMUON), } kwargs_muons_reverse_pid = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU < -2, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU < -2, label="PID"), F.ISMUON), } kwargs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_spruce.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_spruce.py index 70e59f672e3..f09886257b4 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_spruce.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_exclusive_spruce.py @@ -73,11 +73,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_bu_base = { @@ -87,11 +93,14 @@ kwargs_kaons_for_bu_base = { } kwargs_kaons_for_bu = { **kwargs_kaons_for_bu_base, - "pid": F.require_all(F.PID_K > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_bu_reverse_pid = { **kwargs_kaons_for_bu_base, - "pid": (F.PID_K < 4), + "pid": F.conditionally_skip((F.PID_K < 4), label="PID"), } kwargs_kaons_for_kstar_base = { @@ -101,11 +110,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 1.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 1.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -115,11 +130,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -129,11 +150,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_muons_base = { @@ -143,11 +170,11 @@ kwargs_muons_base = { } kwargs_muons = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU > -2, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > -2, label="PID"), F.ISMUON), } kwargs_muons_reverse_pid = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU < -2, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU < -2, label="PID"), F.ISMUON), } kwargs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mue_exclusive_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mue_exclusive_hlt2.py index e3291bf3f2f..82abc792eac 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mue_exclusive_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mue_exclusive_hlt2.py @@ -73,11 +73,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_base = { @@ -87,11 +93,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -101,11 +113,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < 0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > 0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -115,11 +133,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 1, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 1, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_muons_base = { @@ -129,11 +153,11 @@ kwargs_muons_base = { } kwargs_muons = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU > 1.0, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > 1.0, label="PID"), F.ISMUON), } kwargs_muons_reverse_pid = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU < 1.0, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU < 1.0, label="PID"), F.ISMUON), } kwargs_electrons_base = { @@ -143,11 +167,17 @@ kwargs_electrons_base = { } kwargs_electrons = { **kwargs_electrons_base, - "pid": F.require_all(F.PID_E > 5.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_E > 5.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_electrons_reverse_pid = { **kwargs_electrons_base, - "pid": F.require_all(F.PID_E < 5.0, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_E < 5.0, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mupi_exclusive_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mupi_exclusive_hlt2.py index db02b9c6af0..361d6c98572 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mupi_exclusive_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_mupi_exclusive_hlt2.py @@ -68,11 +68,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_base = { @@ -82,11 +88,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -96,11 +108,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < -2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > -2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > -2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_from_tau_base = { @@ -110,11 +128,17 @@ kwargs_pions_from_tau_base = { } kwargs_pions_from_tau = { **kwargs_pions_from_tau_base, - "pid": F.require_all(F.PID_K < -2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_from_tau_reverse_pid = { **kwargs_pions_from_tau_base, - "pid": F.require_all(F.PID_K > -2, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > -2, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -124,11 +148,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_muons_base = { @@ -138,11 +168,11 @@ kwargs_muons_base = { } kwargs_muons = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU > -1.5, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU > -1.5, label="PID"), F.ISMUON), } kwargs_muons_reverse_pid = { **kwargs_muons_base, - "pid": F.require_all(F.PID_MU < -1.5, F.ISMUON), + "pid": F.require_all(F.conditionally_skip(F.PID_MU < -1.5, label="PID"), F.ISMUON), } kwargs_bs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pie_exclusive_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pie_exclusive_hlt2.py index 22fa8d57c3b..fe7fdb85d37 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pie_exclusive_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pie_exclusive_hlt2.py @@ -65,11 +65,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_base = { @@ -79,11 +85,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -93,11 +105,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < -3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > -3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > -3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_from_tau_base = { @@ -107,11 +125,17 @@ kwargs_pions_from_tau_base = { } kwargs_pions_from_tau = { **kwargs_pions_from_tau_base, - "pid": F.require_all(F.PID_K < -3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_from_tau_reverse_pid = { **kwargs_pions_from_tau_base, - "pid": F.require_all(F.PID_K > -3, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > -3, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -121,11 +145,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_electrons_base = { @@ -135,11 +165,17 @@ kwargs_electrons_base = { } kwargs_electrons = { **kwargs_electrons_base, - "pid": F.require_all(F.PID_E > 5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_E > 5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_electrons_reverse_pid = { **kwargs_electrons_base, - "pid": F.require_all(F.PID_E < 5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_E < 5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_bs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pipi_exclusive_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pipi_exclusive_hlt2.py index 93ad956b066..29012f93d4d 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pipi_exclusive_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/btostautau_pipi_exclusive_hlt2.py @@ -63,11 +63,17 @@ kwargs_kaons_base = { } kwargs_kaons = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K > 5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_reverse_pid = { **kwargs_kaons_base, - "pid": F.require_all(F.PID_K < 5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_base = { @@ -77,11 +83,17 @@ kwargs_kaons_for_kstar_base = { } kwargs_kaons_for_kstar = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K > 5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > 5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_kaons_for_kstar_reverse_pid = { **kwargs_kaons_for_kstar_base, - "pid": F.require_all(F.PID_K < 5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < 5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_base = { @@ -91,11 +103,17 @@ kwargs_pions_base = { } kwargs_pions = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K < -5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_reverse_pid = { **kwargs_pions_base, - "pid": F.require_all(F.PID_K > -5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > -5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_from_tau_base = { @@ -105,11 +123,17 @@ kwargs_pions_from_tau_base = { } kwargs_pions_from_tau = { **kwargs_pions_from_tau_base, - "pid": F.require_all(F.PID_K < -5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K < -5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_pions_from_tau_reverse_pid = { **kwargs_pions_from_tau_base, - "pid": F.require_all(F.PID_K > -5, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_K > -5, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_base = { @@ -119,11 +143,17 @@ kwargs_protons_base = { } kwargs_protons = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P > 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P > 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_protons_reverse_pid = { **kwargs_protons_base, - "pid": F.require_all(F.PID_P < 4, ~F.ISMUON), + "pid": F.require_all( + F.conditionally_skip(F.PID_P < 4, label="PID"), + F.conditionally_skip(~F.ISMUON, label="ISMUON"), + ), } kwargs_bs_phi = { diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/RpK_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/RpK_builders.py index 0fbb4dbe489..c28ccb049f9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/RpK_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/RpK_builders.py @@ -75,10 +75,15 @@ def make_dihadron_from_pK( protons = make_rd_has_rich_detached_protons( mipchi2dvprimary_min=16, pt_min=300 * MeV, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 2.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 2.0, label="PID"), + ), ) kaons = make_rd_has_rich_detached_kaons( - mipchi2dvprimary_min=16, pt_min=300 * MeV, pid=(F.PID_K > 2.0) + mipchi2dvprimary_min=16, + pt_min=300 * MeV, + pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), ) combination_code = F.require_all( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_Xdilepton_detached_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_Xdilepton_detached_builders.py index 4c6a1e15669..f4c24138172 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_Xdilepton_detached_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_Xdilepton_detached_builders.py @@ -44,7 +44,9 @@ def make_LLP_down_muons( pt_min=pt_muon_min, p_min=p_muon_min, mipchi2dvprimary_min=ipchi2_muon_min, - pid=F.require_all(F.ISMUON, F.PID_MU > pidmu_muon_min), + pid=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > pidmu_muon_min, label="PID") + ), make_particles=make_particles_muon, ) return muons @@ -67,7 +69,9 @@ def make_LLP_long_muons( pt_min=pt_muon_min, p_min=p_muon_min, mipchi2dvprimary_min=ipchi2_muon_min, - pid=F.require_all(F.ISMUON, F.PID_MU > pidmu_muon_min), + pid=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > pidmu_muon_min, label="PID") + ), make_particles=make_particles_muon, ) return muons diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_ll_LFV_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_ll_LFV_builder.py index f48d538a783..f40c1d86a52 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_ll_LFV_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_ll_LFV_builder.py @@ -36,7 +36,7 @@ from RecoConf.rdbuilder_thor import ( def make_taus( pi_pt_min=250 * MeV, best_pi_pt_min=750 * MeV, - pi_pid=F.PID_K < 0.0, + pi_pid=F.conditionally_skip(F.PID_K < 0.0, label="PID"), tau_am_min=600 * MeV, tau_am_max=2100 * MeV, tau_m_min=1000 * MeV, @@ -71,7 +71,7 @@ def make_taus( def make_muons( mu_pt_min=500 * MeV, mu_p_min=2 * GeV, - mu_pid=F.require_all(F.ISMUON, F.PID_MU > 2.0), + mu_pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 2.0, label="PID")), mu_mipchi2dvprimary_min=5.0, ): muons = make_rd_detached_muons( @@ -86,7 +86,7 @@ def make_muons( @configurable def make_electrons( - e_PID=(F.PID_E > 3.0), + e_PID=F.conditionally_skip((F.PID_E > 3.0), label="PID"), e_p_min=2 * GeV, e_pt_min=500 * MeV, e_mipchi2dvprimary_min=5.0, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xgamma_exclusive_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xgamma_exclusive_builders.py index 704bd0f1633..4572cd0a430 100755 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xgamma_exclusive_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xgamma_exclusive_builders.py @@ -86,7 +86,9 @@ def isolation_parts(input, table_for_b=False, vertex_iso=True): cut=F.require_all( in_range(0.0, F.DR2, 0.16), ~F.REQUIRE_CLOSE(F.PT() @ F.FORWARDARG0(), F.PT() @ F.FORWARDARG1()), - F.IS_NOT_H() @ F.FORWARDARG1() > 0.2, + F.conditionally_skip( + F.IS_NOT_H() @ F.FORWARDARG1() > 0.2, label="IS_NOT_H" + ), ), LongTrackIso=False, TTrackIso=False, @@ -440,14 +442,20 @@ def make_rad_neutrals(): @configurable def make_rad_photons(): photons = make_rd_soft_photons() - filter_code = F.require_all(F.PT > 3000 * MeV, F.IS_PHOTON > 0.2) + filter_code = F.require_all( + F.PT > 3000 * MeV, F.conditionally_skip(F.IS_PHOTON > 0.2, label="IS_PHOTON") + ) return ParticleFilter(photons, F.FILTER(filter_code), name="rad_photons_{hash}") def electrons_for_convertedgamma(electrons, name="make_e_for_gee_{hash}"): # make and filter electrons to build converted photons # suitable for both long and down tracks - filter_code = F.require_all(F.PT > 100.0 * MeV, F.P > 1.0 * GeV, F.PID_E > -2.0) + filter_code = F.require_all( + F.PT > 100.0 * MeV, + F.P > 1.0 * GeV, + F.conditionally_skip(F.PID_E > -2.0, label="PID"), + ) return ParticleFilter( electrons(), F.FILTER(filter_code), @@ -484,7 +492,10 @@ def make_gamma_eeLL( """ electrons = electrons_for_convertedgamma(make_long_electrons_no_brem) gamma = loose_gamma_ee(electrons, 50.0 * MeV, pt_diE_min=pt_diE_min, name=name) - code_tight = F.require_any(F.CHILD(1, F.PID_E) > 2.0, F.CHILD(2, F.PID_E) > 2.0) + code_tight = F.require_any( + F.conditionally_skip(F.CHILD(1, F.PID_E) > 2.0, label="PID"), + F.conditionally_skip(F.CHILD(2, F.PID_E) > 2.0, label="PID"), + ) return ParticleFilter(gamma, F.FILTER(code_tight), name=name) @@ -562,7 +573,7 @@ def make_rad_kaons_for_4hg(): F.P > 2500.0 * MeV, F.PT > 400.0 * MeV, F.OWNPVIPCHI2 > 25.0, - F.PID_K > 2.0, + F.conditionally_skip(F.PID_K > 2.0, label="PID"), ) return ParticleFilter(kaons, F.FILTER(filter_code), name="rad_kaons_for_4hg_{hash}") @@ -573,7 +584,7 @@ def make_rad_protons_for_4hg(): F.P > 2500.0 * MeV, F.PT > 400.0 * MeV, F.OWNPVIPCHI2 > 25.0, - F.PID_P > 2.0, + F.conditionally_skip(F.PID_P > 2.0, label="PID"), ) return ParticleFilter( protons, F.FILTER(filter_code), name="rad_protons_for_4hg_{hash}" @@ -713,7 +724,10 @@ def make_rad_loose_ph( m_min, m_max, h_pid, - p_pid=F.require_all(F.PID_P > 2, (F.PID_P - F.PID_K > 2.0)), + p_pid=F.require_all( + F.conditionally_skip(F.PID_P > 2, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K > 2.0), label="PID"), + ), ipchi2_min=9, p_min=2.0 * GeV, pt_min=250.0 * MeV, @@ -756,7 +770,10 @@ def make_rad_loose_pp( protons=make_rd_has_rich_detached_protons, m_min=1876.0 * MeV, m_max=4000.0 * MeV, - p_pid=F.require_all(F.PID_P > 1.0, (F.PID_P - F.PID_K > 1.0)), + p_pid=F.require_all( + F.conditionally_skip(F.PID_P > 1.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K > 1.0), label="PID"), + ), pt_min=250.0 * MeV, ph_pt_min=1000.0 * MeV, ): @@ -781,8 +798,14 @@ def make_rad_loose_pk( kaons=make_rd_has_rich_detached_kaons, m_min=1375.0 * MeV, m_max=2625.0 * MeV, - p_pid=F.require_all(F.PID_P > 2, (F.PID_P - F.PID_K > 2.0)), - k_pid=F.require_all(F.PID_K > 2, (F.PID_K - F.PID_P) > 1), + p_pid=F.require_all( + F.conditionally_skip(F.PID_P > 2, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K > 2.0), label="PID"), + ), + k_pid=F.require_all( + F.conditionally_skip(F.PID_K > 2, label="PID"), + F.conditionally_skip((F.PID_K - F.PID_P) > 1, label="PID"), + ), ): return make_rad_loose_ph( name, @@ -825,8 +848,11 @@ def make_rad_loose_ppi( pions=make_rd_has_rich_detached_pions, m_min=1375.0 * MeV, m_max=2625.0 * MeV, - p_pid=F.require_all(F.PID_P > 2, (F.PID_P - F.PID_K > 2.0)), - pi_pid=(F.PID_K < -1.0), + p_pid=F.require_all( + F.conditionally_skip(F.PID_P > 2, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K > 2.0), label="PID"), + ), + pi_pid=F.conditionally_skip((F.PID_K < -1.0), label="PID"), ownpvvdrho_min=0.075 * mm, p_p_min=9.0 * GeV, p_pt_min=600.0 * MeV, @@ -1030,10 +1056,13 @@ def make_rad_k1(): k1 = make_rd_detached_k1( pi_pt_min=300.0 * MeV, pi_ipchi2_min=7.0, - pi_pid=(F.PID_K < -2), + pi_pid=F.conditionally_skip((F.PID_K < -2), label="PID"), k_pt_min=300.0 * MeV, k_ipchi2_min=7.0, - k_pid=((F.PID_K > 2.0) & ((F.PID_K - F.PID_P) > 2)), + k_pid=( + F.conditionally_skip((F.PID_K > 2.0), label="PID") + & F.conditionally_skip(((F.PID_K - F.PID_P) > 2), label="PID") + ), pt_min=1500.0 * MeV, adocachi2_cut=10.0, vchi2pdof_max=9, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xll_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xll_builders.py index 8a88a68b8b6..65880c5b84b 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xll_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xll_builders.py @@ -239,7 +239,7 @@ def make_rd_detached_kaons_for_hPi0ll( pt_min=pt_kaon_min, p_min=p_kaon_min, mipchi2dvprimary_min=mipchi2dvprimary_min, - pid=(F.PID_K > pid_k_min), + pid=F.conditionally_skip((F.PID_K > pid_k_min), label="PID"), ) @@ -253,7 +253,7 @@ def make_rd_detached_pions_for_hPi0ll( pt_min=pt_pion_min, p_min=p_pion_min, mipchi2dvprimary_min=mipchi2dvprimary_min, - pid=(F.PID_K < pid_k_max), + pid=F.conditionally_skip((F.PID_K < pid_k_max), label="PID"), ) @@ -318,7 +318,7 @@ def make_rd_detached_pions_for_hhPi0ll( pt_min=pt_pion_min, p_min=p_pion_min, mipchi2dvprimary_min=mipchi2dvprimary_min, - pid=(F.PID_K < pid_k_max), + pid=F.conditionally_skip((F.PID_K < pid_k_max), label="PID"), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xtaul_3pi_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xtaul_3pi_builder.py index a013ec7a8a1..cc041964e0a 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xtaul_3pi_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/b_to_xtaul_3pi_builder.py @@ -50,8 +50,11 @@ def make_dihadron_from_pK( make_kaons=make_rd_has_rich_detached_kaons, p_ipchi2_min=9.0, k_ipchi2_min=9.0, - p_pid=F.require_all(F.PID_P > 2.0, F.PID_P - F.PID_K > 0.0), - k_pid=F.PID_K > 8, + p_pid=F.require_all( + F.conditionally_skip(F.PID_P > 2.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), + ), + k_pid=F.conditionally_skip(F.PID_K > 8, label="PID"), pt_min=1 * GeV, am_min=1300 * MeV, am_max=5620 * MeV, @@ -87,7 +90,7 @@ def filter_rd_detached_phis( name="rd_detached_phis_{hash}", k_pt_min=250 * MeV, k_ipchi2_min=9.0, - k_pid=(F.PID_K > 8.0), + k_pid=F.conditionally_skip((F.PID_K > 8.0), label="PID"), pt_min=1 * GeV, vtxchi2_max=9, adocachi2cut=20.0, @@ -135,10 +138,10 @@ def filter_rd_detached_k1( name="rd_detached_k1_{hash}", pi_pt_min=250 * MeV, pi_ipchi2_min=9.0, - pi_pid=F.PID_K < 2.0, + pi_pid=F.conditionally_skip(F.PID_K < 2.0, label="PID"), k_pt_min=250 * MeV, k_ipchi2_min=9.0, - k_pid=F.PID_K > 8.0, + k_pid=F.conditionally_skip(F.PID_K > 8.0, label="PID"), pt_min=1 * GeV, ipchi2_k1_min=9.0, ownpvfdchi2_min=16, @@ -285,7 +288,12 @@ def make_dilepton_from_tauls( pi_ipchi2_min=16.0, best_pi_pt_min=800 * MeV, best_pi_ipchi2_min=25.0, - pi_pid=F.require_all(F.PID_K < 5.0, F.PID_E < 5.0, F.PID_P < 10, F.PID_MU < 10), + pi_pid=F.require_all( + F.conditionally_skip(F.PID_K < 5.0, label="PID"), + F.conditionally_skip(F.PID_E < 5.0, label="PID"), + F.conditionally_skip(F.PID_P < 10, label="PID"), + F.conditionally_skip(F.PID_MU < 10, label="PID"), + ), tau_am_2pi_min=400.0 * MeV, tau_am_2pi_max=1200.0 * MeV, tau_am_2pi_nc_min=600.0 * MeV, @@ -304,8 +312,11 @@ def make_dilepton_from_tauls( e_pt=500 * MeV, mu_p=3 * GeV, e_p=3 * GeV, - mu_pid=F.require_all(F.ISMUON, F.PID_MU > 2.0), - e_pid=F.require_all(F.PID_E > 4.0, F.PID_E - F.PID_K > 0.0), + mu_pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 2.0, label="PID")), + e_pid=F.require_all( + F.conditionally_skip(F.PID_E > 4.0, label="PID"), + F.conditionally_skip(F.PID_E - F.PID_K > 0.0, label="PID"), + ), mu_mipchi2=9.0, e_mipchi2=9.0, am_min=200 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_builders.py index 8a862b0841f..edf13d5408b 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_builders.py @@ -32,7 +32,7 @@ from RecoConf.reconstruction_objects import make_pvs def make_dipion_for_lb( pi_pt_min=0.0 * MeV, pi_ipchi2_min=4.0, - pi_pid=(F.PID_K < -1.0), + pi_pid=F.conditionally_skip((F.PID_K < -1.0), label="PID"), pt_min=300.0 * MeV, am_min=240.0 * MeV, am_max=3500.0 * MeV, @@ -68,7 +68,10 @@ def make_rd_baryon_proton( pt_min=300.0 * MeV, p_min=8.0 * GeV, mipchi2dvprimary_min=4, - pid=F.require_all(F.PID_P > 0.0, F.PID_P - F.PID_K > -2.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 0.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > -2.0, label="PID"), + ), notmuon=False, ): """ @@ -87,7 +90,7 @@ def make_rd_baryon_proton( code &= F.MINIPCHI2(pvs) > mipchi2dvprimary_min if notmuon is True: - code &= ~F.ISMUON + code &= F.conditionally_skip(~F.ISMUON, label="ISMUON") return ParticleFilter(make_particles(), name=name, Cut=F.FILTER(code)) @@ -526,7 +529,7 @@ def make_omegam_to_lambda_k_lll( kaon_p_min=0.0, kaon_pt_min=0.0, kaon_mipchi2dvprimary_min=9.0, - kaon_PID=(F.PID_K > -2.0), + kaon_PID=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): lambdas = make_rd_baryon_l0_ll( vchi2pdof_max=lambda_vchi2pdof_max, @@ -577,7 +580,7 @@ def make_omegam_to_lambda_k_ddl( kaon_p_min=0.0, kaon_pt_min=0.0, kaon_mipchi2dvprimary_min=9.0, - kaon_PID=(F.PID_K > -2.0), + kaon_PID=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): lambdas = make_rd_baryon_l0_dd( vchi2pdof_max=lambda_vchi2pdof_max, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_radiative_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_radiative_builders.py index 7adf5e108b1..bc010d5b065 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_radiative_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/baryonic_radiative_builders.py @@ -371,7 +371,7 @@ def make_omegam_to_lambda_k_lll( kaon_p_min=0.0, kaon_pt_min=0.0, kaon_mipchi2dvprimary_min=9.0, - kaon_PID=(F.PID_K > -2.0), + kaon_PID=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): lambdas = make_rd_lambda_lls( mass_window=lambda_mass_window, @@ -421,7 +421,7 @@ def make_omegam_to_lambda_k_ddl( kaon_p_min=0.0, kaon_pt_min=0.0, kaon_mipchi2dvprimary_min=9.0, - kaon_PID=(F.PID_K > -2.0), + kaon_PID=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): lambdas = make_rd_lambda_dds( mass_window=lambda_mass_window, @@ -470,7 +470,7 @@ def make_omegam_to_lambda_k_ddd( lambda_pt_min=0.0, kaon_p_min=0.0, kaon_pt_min=0.0, - kaon_PID=(F.PID_K > -2.0), + kaon_PID=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): lambdas = make_rd_lambda_dds( mass_window=lambda_mass_window, @@ -620,7 +620,9 @@ def filter_lambdasLL_for_lb_to_lg( F.NINTREE(F.require_all(F.ISBASICPARTICLE, F.GHOSTPROB < trghostprob_max)) == 2, F.MINTREE(F.IS_ABS_ID("pi+"), F.PT) > pi_pt_min, F.MINTREE(F.IS_ABS_ID("p+"), F.PT) > p_pt_min, - F.MINTREE(F.IS_ABS_ID("p+"), F.PID_P) > PIDp_min, + F.conditionally_skip( + F.MINTREE(F.IS_ABS_ID("p+"), F.PID_P) > PIDp_min, label="PID" + ), F.INTREE(F.require_all(F.IS_ABS_ID("p+"), F.OWNPVIP > p_ip_min)), F.CHI2 < vchi2, # "In principle" F.OWNPVIP > L0_ip_min, @@ -652,7 +654,9 @@ def filter_lambdasDD_for_lb_to_lg( F.MINTREE(F.IS_ABS_ID("p+"), F.PT) > p_pt_min, F.MINTREE(F.IS_ABS_ID("pi+"), F.OWNPVIPCHI2) > pi_ipchi2_min, F.MINTREE(F.IS_ABS_ID("p+"), F.OWNPVIPCHI2) > p_ipchi2_min, - F.MINTREE(F.IS_ABS_ID("p+"), F.PID_P) > PIDp_min, + F.conditionally_skip( + F.MINTREE(F.IS_ABS_ID("p+"), F.PID_P) > PIDp_min, label="PID" + ), F.CHI2 < vchi2, in_range(vz_min, F.END_VZ, vz_max), F.PT > L0_pt_min, @@ -781,9 +785,18 @@ def make_rad_xim_lambdapi_ddl(): lambda_p_min=5 * GeV, lambda_doca_max=2, # track PIDs - pion_PID=F.require_all(F.PROBNN_PI > 0.4, F.PROBNN_GHOST < 0.6), - lambda_pion_PID=F.require_all(F.PROBNN_PI > 0.4, F.PROBNN_GHOST < 0.6), - lambda_proton_PID=F.require_all(F.PROBNN_P > 0.4, F.PROBNN_GHOST < 0.6), + pion_PID=F.require_all( + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < 0.6, label="PROBNN"), + ), + lambda_pion_PID=F.require_all( + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < 0.6, label="PROBNN"), + ), + lambda_proton_PID=F.require_all( + F.conditionally_skip(F.PROBNN_P > 0.4, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < 0.6, label="PROBNN"), + ), ) return xim @@ -814,9 +827,18 @@ def make_rad_xim_lambdapi_ddd(): lambda_p_min=5 * GeV, lambda_doca_max=3, # track PIDs - pion_PID=F.require_all(F.PROBNN_PI > 0.4, F.PROBNN_GHOST < 0.6), - lambda_pion_PID=F.require_all(F.PROBNN_PI > 0.4, F.PROBNN_GHOST < 0.6), - lambda_proton_PID=F.require_all(F.PROBNN_P > 0.4, F.PROBNN_GHOST < 0.6), + pion_PID=F.require_all( + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < 0.6, label="PROBNN"), + ), + lambda_pion_PID=F.require_all( + F.conditionally_skip(F.PROBNN_PI > 0.4, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < 0.6, label="PROBNN"), + ), + lambda_proton_PID=F.require_all( + F.conditionally_skip(F.PROBNN_P > 0.4, label="PROBNN"), + F.conditionally_skip(F.PROBNN_GHOST < 0.6, label="PROBNN"), + ), ) return xim @@ -841,7 +863,7 @@ def make_rad_omegam_lambdak_lll(): kaon_p_min=5.0 * GeV, kaon_pt_min=400.0 * MeV, kaon_mipchi2dvprimary_min=9.0, - kaon_PID=(F.PID_K > 6.0), + kaon_PID=F.conditionally_skip((F.PID_K > 6.0), label="PID"), ) return omegam @@ -866,7 +888,7 @@ def make_rad_omegam_lambdak_ddl(): kaon_p_min=5.0 * GeV, kaon_pt_min=400.0 * MeV, kaon_mipchi2dvprimary_min=9.0, - kaon_PID=(F.PID_K > 6.0), + kaon_PID=F.conditionally_skip((F.PID_K > 6.0), label="PID"), ) return omegam @@ -890,7 +912,7 @@ def make_rad_omegam_lambdak_ddd(): lambda_pt_min=1.0 * GeV, kaon_p_min=5.0 * GeV, kaon_pt_min=400.0 * MeV, - kaon_PID=(F.PID_K > 6.0), + kaon_PID=F.conditionally_skip((F.PID_K > 6.0), label="PID"), ) return omegam diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/prompt_multilepton_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/prompt_multilepton_builders.py index e5b0ea5a7a6..87f4cff9f2a 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/prompt_multilepton_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/prompt_multilepton_builders.py @@ -42,7 +42,9 @@ from RecoConf.standard_particles import make_long_pions def make_prompt_four_muon( name, parent_id="J/psi(1S)", - pid_cut_mu=F.require_all(F.ISMUON, F.PID_MU > 2.0), + pid_cut_mu=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 2.0, label="PID") + ), pid_best=6, comb_m_min=400 * MeV, comb_m_max=13000 * MeV, @@ -65,7 +67,7 @@ def make_prompt_four_muon( muons = make_rd_prompt_muons(pid=pid_cut_mu) comb_cut_12 = F.require_all( F.MAXSDOCACHI2CUT(docachi2_max), - F.MAX(F.PID_MU) > pid_best, + F.conditionally_skip(F.MAX(F.PID_MU) > pid_best, label="PID"), in_range(comb12_m_min, F.MASS, comb12_m_max), ) comb_cut_123 = F.require_all( @@ -98,8 +100,10 @@ def make_prompt_four_muon( @configurable def make_prompt_3mue( name, - pid_cut_mu=F.require_all(F.ISMUON, F.PID_MU > 2.0), - pid_cut_e=(F.PID_E > 5.5), + pid_cut_mu=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 2.0, label="PID") + ), + pid_cut_e=F.conditionally_skip((F.PID_E > 5.5), label="PID"), pid_best=5.5, parent_id="J/psi(1S)", comb_m_min=0 * MeV, @@ -119,7 +123,9 @@ def make_prompt_3mue( muons = make_rd_prompt_muons(pid=pid_cut_mu, pt_min=350.0 * MeV) electrons = make_rd_prompt_electrons(pt_min=400.0 * MeV, pid=pid_cut_e) comb_cut_12 = F.require_all( - F.MASS < comb_m_max, F.MAXSDOCACHI2CUT(docachi2_max), F.MAX(F.PID_MU) > pid_best + F.MASS < comb_m_max, + F.MAXSDOCACHI2CUT(docachi2_max), + F.conditionally_skip(F.MAX(F.PID_MU) > pid_best, label="PID"), ) comb_cut_123 = F.require_all(F.MASS < comb_m_max, F.MAXSDOCACHI2CUT(docachi2_max)) comb_cut = F.require_all( @@ -167,7 +173,7 @@ def make_prompt_2mu2e( Make J/psi(1S) -> rho(770)0 omega(782); which essetinally should be mu+ mu- e+ e-. """ dimuons = make_rd_prompt_dimuons( - pid=F.require_all(F.ISMUON, F.PID_MU > 3.5), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 3.5, label="PID")), pt_muon_min=300.0 * MeV, pid_best=pid_best, pt_best=pt_best, @@ -225,7 +231,9 @@ def make_prompt_2muSS2eSS( """ dimuons = make_rd_prompt_dimuons( same_sign=True, - pid=F.require_all(F.ISMUON, F.PID_MU > pid_best), + pid=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > pid_best, label="PID") + ), pt_muon_min=350.0 * MeV, pt_best=pt_best, p_best=p_best, @@ -281,8 +289,10 @@ def make_prompt_mue2e( Make [J/psi(1S) -> f_0(980) omega(782)]cc; which essetinally should be mu+ e- e+ e-. """ dileptons = make_rd_prompt_mue( - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 5.5), - pid_electron=(F.PID_E > 6.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 5.5, label="PID") + ), + pid_electron=F.conditionally_skip((F.PID_E > 6.0), label="PID"), pt_muon_min=300.0 * MeV, pt_electron_min=300.0 * MeV, pt_best=pt_best, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/qqbar_to_ll_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/qqbar_to_ll_builders.py index d988cd702e4..f16374890a9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/qqbar_to_ll_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/qqbar_to_ll_builders.py @@ -100,7 +100,7 @@ def make_prompt_tautau( pi_ipchi2_min=3.0, best_pi_pt_min=800 * MeV, best_pi_ipchi2_min=5.0, - pi_pid=F.PID_K <= 0.0, + pi_pid=F.conditionally_skip(F.PID_K <= 0.0, label="PID"), am_min=900 * MeV, am_max=1700 * MeV, am_2pi_min=200 * MeV, @@ -164,7 +164,7 @@ def make_prompt_etau( pi_ipchi2_min=3.0, best_pi_pt_min=800 * MeV, best_pi_ipchi2_min=5.0, - pi_pid=F.PID_K <= 0.0, + pi_pid=F.conditionally_skip(F.PID_K <= 0.0, label="PID"), am_min=900 * MeV, am_max=1700 * MeV, am_2pi_min=200 * MeV, @@ -175,7 +175,9 @@ def make_prompt_etau( name="prompt_tau_builder_{hash}", ) electrons = make_rd_prompt_electrons( - pt_min=min_pt_e, p_min=min_p_e, pid=(F.PID_E > min_pid_e) + pt_min=min_pt_e, + p_min=min_p_e, + pid=F.conditionally_skip((F.PID_E > min_pid_e), label="PID"), ) combination_code = F.require_all( F.MAXSDOCACHI2CUT(max_adocachi2), @@ -228,7 +230,7 @@ def make_prompt_mutau( pi_ipchi2_min=6.0, # possible tighter best_pi_pt_min=800 * MeV, # possible tighter best_pi_ipchi2_min=9.0, - pi_pid=F.PID_K <= 0.0, + pi_pid=F.conditionally_skip(F.PID_K <= 0.0, label="PID"), am_min=900 * MeV, # raja suggestion am_max=1700 * MeV, am_2pi_min=200 * MeV, @@ -243,11 +245,15 @@ def make_prompt_mutau( muons = make_rd_prompt_muons( pt_min=min_pt_mu, p_min=min_p_mu, - pid=F.require_all(F.PID_MU > min_PIDmu, F.ISMUON), + pid=F.require_all( + F.conditionally_skip(F.PID_MU > min_PIDmu, label="PID"), F.ISMUON + ), ) else: muons = make_rd_prompt_muons( - pt_min=min_pt_mu, p_min=min_p_mu, pid=(F.PID_MU > min_PIDmu) + pt_min=min_pt_mu, + p_min=min_p_mu, + pid=F.conditionally_skip((F.PID_MU > min_PIDmu), label="PID"), ) combination_code = F.MAXSDOCACHI2CUT(max_adocachi2) vertex_code = F.require_all( @@ -280,7 +286,7 @@ def make_upsilons_to_upsilons( # pion cut pi_pt_min=500 * MeV, pi_ipchi2_min=0.0, # check if you want to filter on OWNPVIPCHI2 > 0. or OWNPVIPCHI2 > 1. - pi_pid=F.PID_K <= 0, + pi_pid=F.conditionally_skip(F.PID_K <= 0, label="PID"), max_vchi2ndof=9.0, useDTFMassConstraint=False, ): diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/rare_tau_decay_builders.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/rare_tau_decay_builders.py index 9531c5c6452..59b18c4166c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/rare_tau_decay_builders.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/rare_tau_decay_builders.py @@ -26,7 +26,7 @@ def _make_rd_rare_tau_detached_muons( name="_rd_rare_tau_detached_muons_{hash}", mipchi2dvprimary_min=9, pt_min=300 * MeV, - pid=F.require_all(F.ISMUON, F.PID_MU > 2), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 2, label="PID")), **kwargs, ): """helper function to make the rare tau detached muons""" @@ -44,7 +44,7 @@ def _make_rd_rare_tau_detached_electrons( name="_rd_rare_tau_detached_electrons_{hash}", mipchi2dvprimary_min=9, pt_min=300 * MeV, - pid=(F.PID_E > 4), + pid=F.conditionally_skip((F.PID_E > 4), label="PID"), **kwargs, ): """Make the rare tau detached electrons candidate""" @@ -79,7 +79,7 @@ def _make_tau_to_3body( particle3, descriptor, name="HLT2RD_TauTo3Body_Builder", - pid_cut=(F.PID_MU > 0), + pid_cut=F.conditionally_skip((F.PID_MU > 0), label="PID"), min_particle_with_pid=0, min_mass12=0 * MeV, max_mass12=1978 * MeV, @@ -121,7 +121,7 @@ def _make_tau_to_2body( particle2, descriptor, name="HLT2RD_TauTo2Body_Builder", - pid_cut=(F.PID_MU > 0), + pid_cut=F.conditionally_skip((F.PID_MU > 0), label="PID"), min_particle_with_pid=0, min_mass=1578 * MeV, max_mass=1978 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py index 8584bdeb948..e462dce32bf 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py @@ -817,12 +817,18 @@ MAX_OWNPVIP = optional_functor(lambda v: F.OWNPVIP < v) MIN_OWNPVIP = optional_functor(lambda v: F.OWNPVIP >= v) MAX_OWNPVIPCHI2 = optional_functor(lambda v: F.OWNPVIPCHI2 < v) MIN_OWNPVIPCHI2 = optional_functor(lambda v: F.OWNPVIPCHI2 >= v) -MIN_PID_MU = optional_functor(lambda v: F.PID_MU >= v) -MIN_PID_P = optional_functor(lambda v: F.PID_P >= v) -MIN_PID_P_OVER_K = optional_functor(lambda v: (F.PID_P - F.PID_K) >= v) -MIN_PID_K = optional_functor(lambda v: F.PID_K >= v) -MIN_PID_K_OVER_P = optional_functor(lambda v: (F.PID_K - F.PID_P) >= v) -MIN_PID_E = optional_functor(lambda v: F.PID_E >= v) +MIN_PID_MU = optional_functor( + lambda v: F.conditionally_skip(F.PID_MU >= v, label="PID") +) +MIN_PID_P = optional_functor(lambda v: F.conditionally_skip(F.PID_P >= v, label="PID")) +MIN_PID_P_OVER_K = optional_functor( + lambda v: F.conditionally_skip((F.PID_P - F.PID_K) >= v, label="PID") +) +MIN_PID_K = optional_functor(lambda v: F.conditionally_skip(F.PID_K >= v, label="PID")) +MIN_PID_K_OVER_P = optional_functor( + lambda v: F.conditionally_skip((F.PID_K - F.PID_P) >= v, label="PID") +) +MIN_PID_E = optional_functor(lambda v: F.conditionally_skip(F.PID_E >= v, label="PID")) MAX_DOCA = optional_functor(lambda v: F.MAXSDOCACUT(v)) MAX_DOCACHI2 = optional_functor(lambda v: F.MAXSDOCACHI2CUT(v)) MIN_OWNPVVDZ = optional_functor(lambda v: F.OWNPVVDZ >= v) @@ -832,9 +838,15 @@ MIN_RHO = optional_functor(lambda v: F.END_VX**2 + F.END_VY**2 >= v**2) MIN_OWNPVLTIME = optional_functor(lambda v: F.OWNPVLTIME >= v) MIN_DIRA = optional_functor(lambda v: F.OWNPVDIRA >= v) IS_MUON = optional_functor(lambda v: F.ISMUON if v else not F.ISMUON) -MIN_IS_NOT_H = optional_functor(lambda v: F.IS_NOT_H >= v) -MIN_IS_PHOTON = optional_functor(lambda v: F.IS_PHOTON >= v) -MAX_IS_PHOTON = optional_functor(lambda v: F.IS_PHOTON < v) +MIN_IS_NOT_H = optional_functor( + lambda v: F.conditionally_skip(F.IS_NOT_H >= v, label="IS_NOT_H") +) +MIN_IS_PHOTON = optional_functor( + lambda v: F.conditionally_skip(F.IS_PHOTON >= v, label="IS_PHOTON") +) +MAX_IS_PHOTON = optional_functor( + lambda v: F.conditionally_skip(F.IS_PHOTON < v, label="IS_PHOTON") +) MAX_END_VZ = optional_functor(lambda v: F.END_VZ < v) IN_ECAL = optional_functor(lambda v: F.INECAL if v else not F.INECAL) @@ -1729,16 +1741,15 @@ def particle_maker(particle_name, basic_type="charged"): **REQUIREMENTS_FOR_PARTICLE_ID[particle_name][tags], } - if tags.selection == "standard": + if F.conditionally_skip(tags.selection == "standard"): tags_mod = tags.modified(selection="loose") - elif tags.selection == "tight": + elif F.conditionally_skip(tags.selection == "tight"): tags_mod = tags.modified(selection="standard") else: tags_mod = None - has_lower_requirements = ( - tags_mod is not None - and rec_requirements[tags] is not rec_requirements[tags_mod] + has_lower_requirements = tags_mod is not None and F.conditionally_skip( + rec_requirements[tags] is not rec_requirements[tags_mod] ) if has_lower_requirements: diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/prompt_multilepton.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/prompt_multilepton.py index 1fd4022c9c3..51bccc77342 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/prompt_multilepton.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/prompt_multilepton.py @@ -129,7 +129,9 @@ def Hlt2RD_LowMassTo4Mu(name="Hlt2RD_LowMassTo4Mu", prescale=1, persistreco=Fals comb_m_max=1300 * MeV, m_min=400 * MeV, m_max=1200 * MeV, - pid_cut_mu=F.require_all(F.ISMUON, F.PID_MU > 1.0), + pid_cut_mu=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 1.0, label="PID") + ), pid_best=5.0, pt_best=0.45 * GeV, p_best=4.5 * GeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/qqbar_to_ll.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/qqbar_to_ll.py index af2ef1a64ef..b1312d65c1f 100755 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/qqbar_to_ll.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/qqbar_to_ll.py @@ -78,7 +78,9 @@ def phi_to_mue_line(name="Hlt2RD_PhiToMuE", prescale=0.01, persistreco=False): am_min=850.0 * MeV, # 850 am_max=1170.0 * MeV, # 1220 pt_dilepton_min=0.5 * GeV, - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), same_sign=False, ) return Hlt2Line( @@ -99,7 +101,9 @@ def phi_to_mue_ss_line(name="Hlt2RD_PhiToMuE_SS", prescale=0.001, persistreco=Fa am_min=850.0 * MeV, am_max=1170.0 * MeV, pt_dilepton_min=0.5 * GeV, - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), same_sign=True, ) return Hlt2Line( @@ -122,7 +126,9 @@ def jpsi_to_mue_line(name="Hlt2RD_JpsiToMuE", prescale=0.1, persistreco=False): pt_dilepton_min=2.5 * GeV, pt_electron_min=1.0 * GeV, pt_muon_min=1.0 * GeV, - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), ) return Hlt2Line( name=name, @@ -146,7 +152,9 @@ def jpsi_to_mue_ss_line(name="Hlt2RD_JpsiToMuE_SS", prescale=0.1, persistreco=Fa pt_dilepton_min=2.5 * GeV, pt_electron_min=1.0 * GeV, pt_muon_min=1.0 * GeV, - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), same_sign=True, ) return Hlt2Line( @@ -171,7 +179,9 @@ def upsilon_to_mue_line(name="Hlt2RD_UpsilonToMuE", prescale=1, persistreco=Fals pt_dilepton_min=2.0 * GeV, pt_electron_min=1.0 * GeV, pt_muon_min=1.0 * GeV, - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), same_sign=False, ) return Hlt2Line( @@ -198,7 +208,9 @@ def upsilon_to_mue_ss_line( pt_dilepton_min=2.0 * GeV, pt_electron_min=1.0 * GeV, pt_muon_min=1.0 * GeV, - pid_muon=F.require_all(F.ISMUON, F.PID_MU > 3.0), + pid_muon=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), same_sign=True, ) return Hlt2Line( @@ -489,7 +501,7 @@ def upsilon_to_mumu_line(name="Hlt2RD_UpsilonToMuMu", prescale=1, persistreco=Fa mumu = make_rd_prompt_dimuons( parent_id="Upsilon(1S)", same_sign=False, - pid=F.require_all(F.PID_MU > 3.0, F.ISMUON), + pid=F.require_all(F.conditionally_skip(F.PID_MU > 3.0, label="PID"), F.ISMUON), pt_dimuon_min=1000.0 * MeV, pt_muon_min=1000.0 * MeV, p_muon_min=1000.0 * MeV, @@ -542,7 +554,7 @@ def upsilon2_to_upsilon1pipi_mumu_line( upsilons1s = make_rd_prompt_dimuons( parent_id="Upsilon(1S)", same_sign=False, - pid=F.require_all(F.PID_MU > 3.0, F.ISMUON), + pid=F.require_all(F.conditionally_skip(F.PID_MU > 3.0, label="PID"), F.ISMUON), pt_dimuon_min=1000.0 * MeV, pt_muon_min=1000.0 * MeV, p_muon_min=1000.0 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/rare_tau_decay_lines.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/rare_tau_decay_lines.py index b8c2ae64697..159ef64828e 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/rare_tau_decay_lines.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/rare_tau_decay_lines.py @@ -82,7 +82,7 @@ def make_rd_rare_tau_detached_muons_lowPT_loosePIDMU( ): params = dict( pt_min=0 * MeV, - pid=F.require_all(F.ISMUON, F.PID_MU > 0), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 0, label="PID")), ) return _make_rd_rare_tau_detached_muons(name=name, **params) @@ -91,7 +91,12 @@ def make_rd_rare_tau_detached_muons_loosePIDMU( name="make_rd_rare_tau_detached_muons_loosePIDMU_{hash}", ): params = dict( - pid=F.require_all(F.ISMUON, F.PID_MU > 0, F.GHOSTPROB < 0.5, F.CHI2DOF < 4) + pid=F.require_all( + F.ISMUON, + F.conditionally_skip(F.PID_MU > 0, label="PID"), + F.GHOSTPROB < 0.5, + F.CHI2DOF < 4, + ) ) return _make_rd_rare_tau_detached_muons(name=name, **params) @@ -100,7 +105,9 @@ def make_rd_rare_tau_detached_muons_loosePIDMU( def make_rd_rare_tau_detached_muons_veryloosePIDMU( name="make_rd_rare_tau_detached_muons_veryloosePIDMU_{hash}", ): - params = dict(pid=F.require_all(F.ISMUON, (F.PID_MU > -5))) + params = dict( + pid=F.require_all(F.ISMUON, F.conditionally_skip((F.PID_MU > -5), label="PID")) + ) return _make_rd_rare_tau_detached_muons(name=name, **params) @@ -108,7 +115,13 @@ def make_rd_rare_tau_detached_muons_veryloosePIDMU( def make_rd_rare_tau_detached_muons_PIDMU( name="make_rd_rare_tau_detached_muons_PIDMU_{hash}", ): - params = dict(pid=F.require_all(F.PID_MU > 0, F.GHOSTPROB < 0.5, F.CHI2DOF < 4)) + params = dict( + pid=F.require_all( + F.conditionally_skip(F.PID_MU > 0, label="PID"), + F.GHOSTPROB < 0.5, + F.CHI2DOF < 4, + ) + ) return _make_rd_rare_tau_detached_muons(name=name, **params) @@ -134,7 +147,10 @@ def make_rd_rare_tau_detached_protons(name="rd_rare_tau_detached_protons_{hash}" default_params = dict( mipchi2dvprimary_min=9, pt_min=300 * MeV, - pid=F.require_all(F.PID_P > 4.0, F.PID_P - F.PID_K > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 4.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 0.0, label="PID"), + ), ) return make_rd_has_rich_detached_protons(name=name, **default_params) @@ -200,7 +216,7 @@ def make_rd_detached_phis_kk(name="make_rd_detached_phis_kk_{hash}"): k_p_min=3.0 * GeV, k_pt_min=450 * MeV, k_ipchi2_min=4, - k_pid=(F.PID_K > 4), + k_pid=F.conditionally_skip((F.PID_K > 4), label="PID"), vchi2pdof_max=10, ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHbprimeLNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHbprimeLNu.py index 701a7b78d9a..60e3fd17836 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHbprimeLNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHbprimeLNu.py @@ -66,7 +66,7 @@ def make_bctobsx(process, BcDecay, BsDecay): pt_min=1000 * MeV, mipchi2_min=0, mip_min=0.05, - pid=(F.PID_E > -0.2), + pid=F.conditionally_skip((F.PID_E > -0.2), label="PID"), ) descriptor_rs = "[B_c+ -> B_s0 e+]cc" descriptor_ws = "[B_c+ -> B_s0 e-]cc" @@ -76,7 +76,7 @@ def make_bctobsx(process, BcDecay, BsDecay): pt_min=350 * MeV, mipchi2_min=0, mip_min=0.02, - pid=(F.PID_K < 2.0), + pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), ) descriptor_rs = "[B_c+ -> B_s0 pi+]cc" descriptor_ws = "[B_c+ -> B_s0 pi-]cc" @@ -86,7 +86,7 @@ def make_bctobsx(process, BcDecay, BsDecay): pt_min=350 * MeV, mipchi2_min=0, mip_min=0.05, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ) descriptor_rs = "[B_c+ -> B_s0 K+]cc" descriptor_ws = "[B_c+ -> B_s0 K-]cc" @@ -112,11 +112,11 @@ def make_bctobsx(process, BcDecay, BsDecay): bpvdira_min=0.99, bpvfdchi2_min=25, bpvvdz_min=0 * mm, - kaon_pid=(F.PID_K > 5.0), - pion_pid=(F.PID_K < -2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < -2.0), label="PID"), ) pis_from_bs = make_pions_from_b( - pid=(F.PID_K < 2), + pid=F.conditionally_skip((F.PID_K < 2), label="PID"), p_min=1000 * MeV, pt_min=500 * MeV, mipchi2_min=16, @@ -143,11 +143,11 @@ def make_bctobsx(process, BcDecay, BsDecay): bpvdira_min=0.99, bpvfdchi2_min=25, bpvvdz_min=0 * mm, - kaon_pid=(F.PID_K > 5.0), - pion_pid=(F.PID_K < -2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < -2.0), label="PID"), ) ks_from_bs = make_kaons_from_b( - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), p_min=1000 * MeV, pt_min=500 * MeV, mipchi2_min=16, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcLNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcLNu.py index 5d80d6e6ce2..c97eea619d7 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcLNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcLNu.py @@ -118,7 +118,7 @@ def make_butod0lnu_d0tokpi(process, lepton): leptons = make_electrons_from_b( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E > 2.0), + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -137,8 +137,12 @@ def make_butod0lnu_d0tokpi(process, lepton): "daughter_pt_min": 300 * MeV, "daughter_p_min": 5 * GeV, "daughter_mipchi2_min": 45, - "kaon_pid": F.require_all(F.PID_K > 4.0, F.GHOSTPROB < 0.35), - "pion_pid": F.require_all(F.PID_K < 0.0, F.GHOSTPROB < 0.35), + "kaon_pid": F.require_all( + F.conditionally_skip(F.PID_K > 4.0, label="PID"), F.GHOSTPROB < 0.35 + ), + "pion_pid": F.require_all( + F.conditionally_skip(F.PID_K < 0.0, label="PID"), F.GHOSTPROB < 0.35 + ), } else: cuts = {"mother_p_min": 5 * GeV} @@ -191,7 +195,7 @@ def make_butod0lnu_d0tokpi_fakelepton(process, lepton, is_decayinflight=False): fake_leptons = make_fake_electrons_from_b_reversedPID( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E < 2.0), + pid=F.conditionally_skip((F.PID_E < 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -210,8 +214,12 @@ def make_butod0lnu_d0tokpi_fakelepton(process, lepton, is_decayinflight=False): "daughter_pt_min": 300 * MeV, "daughter_p_min": 5 * GeV, "daughter_mipchi2_min": 45, - "kaon_pid": F.require_all(F.PID_K > 4.0, F.GHOSTPROB < 0.35), - "pion_pid": F.require_all(F.PID_K < 0.0, F.GHOSTPROB < 0.35), + "kaon_pid": F.require_all( + F.conditionally_skip(F.PID_K > 4.0, label="PID"), F.GHOSTPROB < 0.35 + ), + "pion_pid": F.require_all( + F.conditionally_skip(F.PID_K < 0.0, label="PID"), F.GHOSTPROB < 0.35 + ), } else: cuts = {"mother_p_min": 5 * GeV} @@ -397,7 +405,7 @@ def make_butod0lnu_d0tok3pi(process, lepton): leptons = make_electrons_from_b( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E > 2.0), + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -414,8 +422,8 @@ def make_butod0lnu_d0tok3pi(process, lepton): "daughter_pt_min": 750 * MeV, "vchi2pdof_max": 5.0, "bpvdira_min": 0.9998, - "kaon_pid": (F.PID_K > 4.0), - "pion_pid": (F.PID_K < 2.0), + "kaon_pid": F.conditionally_skip((F.PID_K > 4.0), label="PID"), + "pion_pid": F.conditionally_skip((F.PID_K < 2.0), label="PID"), } # Tighter D0 cut else: cuts = {"mother_p_min": 5 * GeV} @@ -451,7 +459,7 @@ def make_butod0lnu_d0tok3pi_fakelepton(process, lepton, is_decayinflight=False): fake_leptons = make_fake_electrons_from_b_reversedPID( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E < 2.0), + pid=F.conditionally_skip((F.PID_E < 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -468,8 +476,8 @@ def make_butod0lnu_d0tok3pi_fakelepton(process, lepton, is_decayinflight=False): "vchi2pdof_max": 5.0, "bpvdira_min": 0.9998, "daughter_pt_min": 750 * MeV, - "kaon_pid": (F.PID_K > 4.0), - "pion_pid": (F.PID_K < 2.0), + "kaon_pid": F.conditionally_skip((F.PID_K > 4.0), label="PID"), + "pion_pid": F.conditionally_skip((F.PID_K < 2.0), label="PID"), } # Tighter D0 cut else: cuts = {"mother_p_min": 5 * GeV} @@ -711,7 +719,10 @@ def make_lbtolclnu_lctoV0h(process, V0_name, V0_type, lepton_name): elif lepton_name == "e": # apply slightly tighter cuts to default leptons = make_electrons_from_b( - p_min=7.5 * GeV, pt_min=2.0 * GeV, mipchi2_min=12.0, pid=(F.PID_E > 2.0) + p_min=7.5 * GeV, + pt_min=2.0 * GeV, + mipchi2_min=12.0, + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), ) descriptor_rs = "[Lambda_b0 -> Lambda_c+ e-]cc" descriptor_ws = "[Lambda_b0 -> Lambda_c+ e+]cc" @@ -776,7 +787,10 @@ def make_lbtolclnu_lctoV0h_fakelepton( descriptor_ws = "[Lambda_b0 -> Lambda_c+ mu+]cc" elif lepton_name == "e": leptons = make_fake_electrons_from_b_reversedPID( - p_min=7.5 * GeV, pt_min=2.0 * GeV, mipchi2_min=12.0, pid=(F.PID_E < 2.0) + p_min=7.5 * GeV, + pt_min=2.0 * GeV, + mipchi2_min=12.0, + pid=F.conditionally_skip((F.PID_E < 2.0), label="PID"), ) descriptor_rs = "[Lambda_b0 -> Lambda_c+ e-]cc" descriptor_ws = "[Lambda_b0 -> Lambda_c+ e+]cc" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToLNuNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToLNuNu.py index d21203c4add..24cff069be9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToLNuNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToLNuNu.py @@ -108,7 +108,7 @@ def make_butod0taunu_d0tokpi_tautolnunu(process, lepton): taus = make_tauons_electronic_decay( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E > 2.0), + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -126,8 +126,12 @@ def make_butod0taunu_d0tokpi_tautolnunu(process, lepton): "daughter_pt_min": 300 * MeV, "daughter_p_min": 5 * GeV, "daughter_mipchi2_min": 45, - "kaon_pid": F.require_all(F.PID_K > 4.0, F.GHOSTPROB < 0.35), - "pion_pid": F.require_all(F.PID_K < 0.0, F.GHOSTPROB < 0.35), + "kaon_pid": F.require_all( + F.conditionally_skip(F.PID_K > 4.0, label="PID"), F.GHOSTPROB < 0.35 + ), + "pion_pid": F.require_all( + F.conditionally_skip(F.PID_K < 0.0, label="PID"), F.GHOSTPROB < 0.35 + ), } if lepton == "mu": @@ -139,8 +143,8 @@ def make_butod0taunu_d0tokpi_tautolnunu(process, lepton): comb_pt_sum_min=2.5 * GeV, comb_doca_max=0.1 * mm, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), comb_docachi2_max=None, daughter_pt_min=300.0 * MeV, daughter_p_min=5 * GeV, @@ -197,7 +201,7 @@ def make_butod0taunu_d0tokpi_tautolnunu_fakelepton( taus = make_fake_tauons_electronic_decay( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E < 2.0), + pid=F.conditionally_skip((F.PID_E < 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -215,8 +219,12 @@ def make_butod0taunu_d0tokpi_tautolnunu_fakelepton( "daughter_pt_min": 300 * MeV, "daughter_p_min": 5 * GeV, "daughter_mipchi2_min": 45, - "kaon_pid": F.require_all(F.PID_K > 4.0, F.GHOSTPROB < 0.35), - "pion_pid": F.require_all(F.PID_K < 0.0, F.GHOSTPROB < 0.35), + "kaon_pid": F.require_all( + F.conditionally_skip(F.PID_K > 4.0, label="PID"), F.GHOSTPROB < 0.35 + ), + "pion_pid": F.require_all( + F.conditionally_skip(F.PID_K < 0.0, label="PID"), F.GHOSTPROB < 0.35 + ), } if lepton == "mu": @@ -228,8 +236,8 @@ def make_butod0taunu_d0tokpi_tautolnunu_fakelepton( comb_pt_sum_min=2.5 * GeV, comb_doca_max=0.1 * mm, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), comb_docachi2_max=None, daughter_pt_min=300.0 * MeV, daughter_p_min=5 * GeV, @@ -285,7 +293,7 @@ def make_butod0taunu_d0tok3pi_tautolnunu(process, lepton): tauons = make_tauons_electronic_decay( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E > 2.0), + pid=F.conditionally_skip((F.PID_E > 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -302,8 +310,8 @@ def make_butod0taunu_d0tok3pi_tautolnunu(process, lepton): "bpvdira_min": 0.9998, "daughter_pt_min": 750.0 * MeV, "daughter_p_min": 5 * GeV, - "kaon_pid": (F.PID_K > 2.0), - "pion_pid": (F.PID_K < 4.0), + "kaon_pid": F.conditionally_skip((F.PID_K > 2.0), label="PID"), + "pion_pid": F.conditionally_skip((F.PID_K < 4.0), label="PID"), } if lepton == "mu": dzs = make_d0_tok3pi( @@ -312,8 +320,8 @@ def make_butod0taunu_d0tok3pi_tautolnunu(process, lepton): vchi2pdof_max=5, daughter_pt_min=300.0 * MeV, daughter_p_min=5 * GeV, - kaon_pid=(F.PID_K > 2.0), - pion_pid=(F.PID_K < 4.0), + kaon_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 4.0), label="PID"), ) elif lepton == "e": @@ -347,7 +355,7 @@ def make_butod0taunu_d0tok3pi_tautolnunu_fakelepton( fake_tauons = make_fake_tauons_electronic_decay( p_min=3.0 * GeV, pt_min=300.0 * MeV, - pid=(F.PID_E < 2.0), + pid=F.conditionally_skip((F.PID_E < 2.0), label="PID"), mipchi2_min=15.0, eta_cut=F.require_all(F.ETA > 2.2, F.ETA < 4.2), ) @@ -364,8 +372,8 @@ def make_butod0taunu_d0tok3pi_tautolnunu_fakelepton( "bpvdira_min": 0.9998, "daughter_pt_min": 750.0 * MeV, "daughter_p_min": 5 * GeV, - "kaon_pid": (F.PID_K > 2.0), - "pion_pid": (F.PID_K < 4.0), + "kaon_pid": F.conditionally_skip((F.PID_K > 2.0), label="PID"), + "pion_pid": F.conditionally_skip((F.PID_K < 4.0), label="PID"), } if lepton == "mu": dzs = make_d0_tok3pi( @@ -374,8 +382,8 @@ def make_butod0taunu_d0tok3pi_tautolnunu_fakelepton( vchi2pdof_max=5, daughter_pt_min=300.0 * MeV, daughter_p_min=5 * GeV, - kaon_pid=(F.PID_K > 2.0), - pion_pid=(F.PID_K < 4.0), + kaon_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 4.0), label="PID"), ) elif lepton == "e": @@ -552,8 +560,8 @@ def make_lbtolctaunu_lctopkpi_tautolnu(process, lepton): lcs = make_lambdac_topkpi( daughter_pt_min=300 * MeV, daughter_mipchi2_min=9, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), ) lb_rightsign = make_b2xtaunu( @@ -600,8 +608,8 @@ def make_lbtolctaunu_lctopkpi_tautolnu_fakelepton( lcs = make_lambdac_topkpi( daughter_pt_min=300.0 * MeV, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), ) fake_lepton = "misID" if not is_decayinflight else "DIF" @@ -758,7 +766,10 @@ def make_xib0toxicplustaunu_xicplustopkpi_tautomununu(process): taus = make_tauons_muonic_decay() # make Xi_c+ candidates - xicplus = make_xicplus_topkpi(pion_pid=(F.PID_K < 2.0), common_daug_mipchi2_min=8.0) + xicplus = make_xicplus_topkpi( + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), + common_daug_mipchi2_min=8.0, + ) # make Xib0 candidates (RS and WS) xibs_rs = make_b2xtaunu( @@ -788,7 +799,10 @@ def make_xib0toxicplustaunu_xicplustopkpi_tautomununu_fakelepton( fake_taus = make_fake_tauons_muonic_decay(is_decayinflight=is_decayinflight) # make Xi_c+ candidates - xicplus = make_xicplus_topkpi(pion_pid=(F.PID_K < 2.0), common_daug_mipchi2_min=8.0) + xicplus = make_xicplus_topkpi( + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), + common_daug_mipchi2_min=8.0, + ) fake_lepton = "misID" if not is_decayinflight else "DIF" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToPiPiPiNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToPiPiPiNu.py index 4628817e9f3..d7ba33f7e93 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToPiPiPiNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHcTauNu_TauToPiPiPiNu.py @@ -51,8 +51,8 @@ def make_bptod0taunu_d0tok3pi_tautopipipinu(process): cuts = { "comb_docachi2_max": 5.0, - "kaon_pid": (F.PID_K > 4.0), - "pion_pid": (F.PID_K < 2.0), + "kaon_pid": F.conditionally_skip((F.PID_K > 4.0), label="PID"), + "pion_pid": F.conditionally_skip((F.PID_K < 2.0), label="PID"), } # Tighter D0 cut d0s = make_d0_tok3pi(**cuts) @@ -177,8 +177,8 @@ def make_bptod0taunu_d0tokpi_tautopipipinu(process): "comb_docachi2_max": 5.0, "daughter_pt_min": 400 * MeV, "daughter_p_min": 2000 * MeV, - "kaon_pid": (F.PID_K > 4.0), - "pion_pid": (F.PID_K < 2.0), + "kaon_pid": F.conditionally_skip((F.PID_K > 4.0), label="PID"), + "pion_pid": F.conditionally_skip((F.PID_K < 2.0), label="PID"), } # Tighter D0 cut, following butod0enu dzeros = make_d0_tokpi(**cuts) @@ -296,14 +296,14 @@ def make_lbtolctaunu_lctopkpi_tautopipipinu(process): tauons = make_tauons_hadronic_decay() lcs_init = make_lambdac_topkpi( - pion_pid=(F.PID_K < 2.0), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), daughter_mipchi2_min=8.0, ) Lc_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -465,7 +465,10 @@ def make_lbtolctaunu_lctopphi_tautopipipinu(process): daughter_p_min=2000 * MeV, daughter_pt_min=400 * MeV, daughter_mipchi2_min=4.0, - proton_pid=F.require_all(F.PID_P > 0.0, (F.PID_P - F.PID_K) > 0.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 0.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 0.0, label="PID"), + ), comb_docachi2_max=20.0, ) @@ -541,7 +544,10 @@ def make_lbtolctaunu_lctoppipi_tautopipipinu(process): daughter_p_min=2000 * MeV, daughter_pt_min=400 * MeV, daughter_mipchi2_min=4.0, - proton_pid=F.require_all(F.PID_P > 0.0, (F.PID_P - F.PID_K) > 0.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 0.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 0.0, label="PID"), + ), comb_docachi2_max=20.0, ) @@ -600,12 +606,14 @@ def make_xib0toxicplustaunu_xicplustopkpi_tautopipipinu(process): descriptor_rs = "[Xi_b0 -> Xi_c+ tau-]cc" descriptor_ws = "[Xi_b0 -> Xi_c+ tau+]cc" - xicplus_init = make_xicplus_topkpi(pion_pid=(F.PID_K < 2.0)) + xicplus_init = make_xicplus_topkpi( + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID") + ) xic_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -648,13 +656,15 @@ def make_xibminustoxic0taunu_xic0topkkpi_tautopipipinu(process): descriptor_rs = "[Xi_b- -> Xi_c0 tau-]cc" descriptor_ws = "[Xi_b- -> Xi_c0 tau+]cc" - xic0_init = make_xic0_topkkpi(pion_pid=(F.PID_K < 2.0)) + xic0_init = make_xic0_topkkpi( + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID") + ) xic0_filt_code = F.require_all( - F.CHILD(1, F.PROBNN_P) > 0.1, - F.CHILD(2, F.PROBNN_K) > 0.1, - F.CHILD(3, F.PROBNN_K) > 0.1, - F.CHILD(4, F.PROBNN_PI) > 0.5, + F.conditionally_skip(F.CHILD(1, F.PROBNN_P) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(2, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(3, F.PROBNN_K) > 0.1, label="PROBNN"), + F.conditionally_skip(F.CHILD(4, F.PROBNN_PI) > 0.5, label="PROBNN"), F.MAXSDOCACUT(0.15 * mm), F.MAXSDOCACHI2CUT(12.0), F.CHILD(1, F.PT) > 400 * MeV, @@ -694,7 +704,9 @@ def make_omegabtoomegactaunu_omegactopkkpi_tautopipipinu(process): descriptor_rs = "[Omega_b- -> Omega_c0 tau-]cc" descriptor_ws = "[Omega_b- -> Omega_c0 tau+]cc" - omegacs = make_omegac_topkkpi(pion_pid=(F.PID_K < 2.0)) + omegacs = make_omegac_topkkpi( + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID") + ) bpvvdrho_min = 0.4 * mm diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuLNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuLNu.py index 7a6669ba76d..d6f26b359d8 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuLNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuLNu.py @@ -79,7 +79,10 @@ def make_lbtopmunu_fakep(process): "Line must be defined as Hlt2 or Sprucing line!" ) protons = make_protons_from_b( - pid=F.require_all(F.PID_P < 10.0, F.PID_P - F.PID_K < 10.0) + pid=F.require_all( + F.conditionally_skip(F.PID_P < 10.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K < 10.0, label="PID"), + ) ) muons = make_muons_for_lbtopmunu() line_alg = make_b2xulnu( @@ -141,7 +144,10 @@ def make_lbtopmunu_ss_fakep(process): "Line must be defined as Hlt2 or Sprucing line!" ) protons = make_protons_from_b( - pid=F.require_all(F.PID_P < 10.0, F.PID_P - F.PID_K < 10.0) + pid=F.require_all( + F.conditionally_skip(F.PID_P < 10.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K < 10.0, label="PID"), + ) ) muons = make_muons_for_lbtopmunu() line_alg = make_b2xulnu( @@ -283,7 +289,9 @@ def make_bstokmunu_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) muons = make_muons_for_btomunu() line_alg = make_b2xulnu( particles=[kaons_nopid, muons], descriptor="[B_s~0 -> K+ mu-]cc" @@ -298,7 +306,9 @@ def make_bstokmunu_ss_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) muons = make_muons_for_btomunu() line_alg = make_b2xulnu( particles=[kaons_nopid, muons], descriptor="[B_s~0 -> K+ mu+]cc" @@ -313,7 +323,9 @@ def make_bstokmunu_fakek_fakemu(process, is_decayinflight=False): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) muons_fake = make_fake_muons_for_btomunu(is_decayinflight=is_decayinflight) line_alg = make_b2xulnu( particles=[kaons_nopid, muons_fake], descriptor="[B_s~0 -> K+ mu-]cc" @@ -412,7 +424,9 @@ def make_bstokenu_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) electrons = make_electrons_for_btoenu() line_alg = make_b2xulnu( particles=[kaons_nopid, electrons], @@ -433,7 +447,9 @@ def make_bstokenu_ss_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) electrons = make_electrons_for_btoenu() line_alg = make_b2xulnu( particles=[kaons_nopid, electrons], @@ -454,7 +470,9 @@ def make_bstokenu_fakek_fakeelectron(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) electrons_reversedpid = make_fake_electrons_for_btoenu() line_alg = make_b2xulnu( particles=[kaons_nopid, electrons_reversedpid], @@ -535,7 +553,9 @@ def make_bstoktaunu_muonic_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) muons = make_muons_for_btomunu(pt_min=500 * MeV) line_alg = make_b2xulnu( particles=[kaons_nopid, muons], descriptor="[B_s~0 -> K+ mu-]cc" @@ -550,7 +570,9 @@ def make_bstoktaunu_muonic_ss_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) muons = make_muons_for_btomunu(pt_min=500 * MeV) line_alg = make_b2xulnu( particles=[kaons_nopid, muons], descriptor="[B_s~0 -> K+ mu+]cc" @@ -565,7 +587,9 @@ def make_bstoktaunu_muonic_fakek_fakemu(process, is_decayinflight=False): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) muons_fake = make_fake_muons_for_btomunu( pt_min=500 * MeV, is_decayinflight=is_decayinflight ) @@ -666,7 +690,9 @@ def make_bstoktaunu_electronic_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) electrons = make_electrons_for_btoenu(pt_min=500 * MeV) line_alg = make_b2xulnu( particles=[kaons_nopid, electrons], @@ -687,7 +713,9 @@ def make_bstoktaunu_electronic_ss_fakek(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) electrons = make_electrons_for_btoenu(pt_min=500 * MeV) line_alg = make_b2xulnu( particles=[kaons_nopid, electrons], @@ -708,7 +736,9 @@ def make_bstoktaunu_electronic_fakek_fakeelectron(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - kaons_nopid = make_kaons_from_b(pid=(F.PID_K <= 5)) + kaons_nopid = make_kaons_from_b( + pid=F.conditionally_skip((F.PID_K <= 5), label="PID") + ) electrons_reversedpid = make_fake_electrons_for_btoenu(pt_min=500 * MeV) line_alg = make_b2xulnu( particles=[kaons_nopid, electrons_reversedpid], diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuTauNu_TauToPiPiPiNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuTauNu_TauToPiPiPiNu.py index f76e1d4a095..af460ba6148 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuTauNu_TauToPiPiPiNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToHuTauNu_TauToPiPiPiNu.py @@ -32,7 +32,9 @@ def make_bstoktaunu_hadronic(process): with make_candidate.bind(track_chisq_ndof_max=2.5, track_ghostprob_max=0.03): kaons = make_kaons_from_b( pid=F.require_all( - F.PID_K > 10, F.PID_K - F.PID_P > 5, F.PID_K - F.PID_MU > 10 + F.conditionally_skip(F.PID_K > 10, label="PID"), + F.conditionally_skip(F.PID_K - F.PID_P > 5, label="PID"), + F.conditionally_skip(F.PID_K - F.PID_MU > 10, label="PID"), ), p_min=12000 * MeV, pt_min=1200 * MeV, @@ -89,7 +91,9 @@ def make_b0topitaunu_hadronic(process): with make_candidate.bind(track_chisq_ndof_max=2.5, track_ghostprob_max=0.03): pions = make_pions_from_b( pid=F.require_all( - F.PID_K < -10, F.PID_K - F.PID_P < -5, F.PID_K - F.PID_MU < -10 + F.conditionally_skip(F.PID_K < -10, label="PID"), + F.conditionally_skip(F.PID_K - F.PID_P < -5, label="PID"), + F.conditionally_skip(F.PID_K - F.PID_MU < -10, label="PID"), ), p_min=12000 * MeV, pt_min=1200 * MeV, @@ -147,7 +151,9 @@ def make_lbtoptaunu_tautopipipinu(process): with make_candidate.bind(track_chisq_ndof_max=2.5, track_ghostprob_max=0.03): protons = make_protons_from_b( pid=F.require_all( - F.PID_P > 12.0, (F.PID_P - F.PID_K) > 12.0, (F.PID_P - F.PID_MU) > 12.0 + F.conditionally_skip(F.PID_P > 12.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 12.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_MU) > 12.0, label="PID"), ), p_min=12000 * MeV, pt_min=1200 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLLLNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLLLNu.py index 9dee560c8af..a3022ea6e29 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLLLNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLLLNu.py @@ -64,7 +64,10 @@ def make_b2mumumunu(name, process, prescale=1): ) muons = make_muons_from_b( - pt_min=300.0 * MeV, p_min=3.0 * GeV, mipchi2_min=9.0, pid=(F.PID_MU > -4.0) + pt_min=300.0 * MeV, + p_min=3.0 * GeV, + mipchi2_min=9.0, + pid=F.conditionally_skip((F.PID_MU > -4.0), label="PID"), ) bps = make_b2lllnu( @@ -88,7 +91,7 @@ def make_b2emumunu(name, process, prescale=1): pt_min=500.0 * MeV, p_min=0.0 * GeV, mipchi2_min=25.0, - pid=(F.PID_E > 0.0), + pid=F.conditionally_skip((F.PID_E > 0.0), label="PID"), require_in_calo=1, ) dimuons = make_detached_dimuon_for_b2lllnu() @@ -111,7 +114,10 @@ def make_b2mueenu(name, process, prescale=1): ) muons = make_muons_from_b( - pt_min=300.0 * MeV, p_min=3.0 * GeV, mipchi2_min=9.0, pid=(F.PID_MU > -4.0) + pt_min=300.0 * MeV, + p_min=3.0 * GeV, + mipchi2_min=9.0, + pid=F.conditionally_skip((F.PID_MU > -4.0), label="PID"), ) dielectrons = make_detached_dielectron_for_b2lllnu() @@ -133,7 +139,10 @@ def make_b2mugammanu_cnvll(name, process, prescale=1): ) muons = make_muons_from_b( - pt_min=1000.0 * MeV, p_min=3.0 * GeV, mipchi2_min=9.0, pid=(F.PID_MU > -4.0) + pt_min=1000.0 * MeV, + p_min=3.0 * GeV, + mipchi2_min=9.0, + pid=F.conditionally_skip((F.PID_MU > -4.0), label="PID"), ) dielectrons = make_gammaLL_for_b2lllnu() @@ -159,7 +168,7 @@ def make_b2eeenu(name, process, prescale=1): pt_min=350.0 * MeV, p_min=0.0 * GeV, mipchi2_min=25.0, - pid=(F.PID_E > 0.0), + pid=F.conditionally_skip((F.PID_E > 0.0), label="PID"), require_in_calo=1, ) @@ -169,7 +178,7 @@ def make_b2eeenu(name, process, prescale=1): F.SUBCOMB(Functor=F.MASS < 1500.0 * MeV, Indices=(2, 3)), ), F.MAX(F.PT) > 500.0 * MeV, - F.MAX(F.PID_E) > 2.0, + F.conditionally_skip(F.MAX(F.PID_E) > 2.0, label="PID"), ) bps = make_b2lllnu( @@ -194,7 +203,7 @@ def make_b2egammanu_cnvll(name, process, prescale=1): pt_min=800.0 * MeV, p_min=3.0 * GeV, mipchi2_min=25.0, - pid=(F.PID_E > -2.0), + pid=F.conditionally_skip((F.PID_E > -2.0), label="PID"), require_in_calo=1, ) dielectrons = make_gammaLL_for_b2lllnu() @@ -261,7 +270,10 @@ def make_b2mumumunu_ss(name, process, prescale=1): ) muons = make_muons_from_b( - pt_min=300.0 * MeV, p_min=3.0 * GeV, mipchi2_min=9.0, pid=(F.PID_MU > -4.0) + pt_min=300.0 * MeV, + p_min=3.0 * GeV, + mipchi2_min=9.0, + pid=F.conditionally_skip((F.PID_MU > -4.0), label="PID"), ) bps = make_b2lllnu( @@ -285,7 +297,7 @@ def make_b2emumunu_ss(name, process, prescale=1): pt_min=500.0 * MeV, p_min=0.0 * GeV, mipchi2_min=25.0, - pid=(F.PID_E > 0.0), + pid=F.conditionally_skip((F.PID_E > 0.0), label="PID"), require_in_calo=1, ) dimuons = make_detached_dimuon_for_b2lllnu(same_sign=True) @@ -308,7 +320,10 @@ def make_b2mueenu_ss(name, process, prescale=1): ) muons = make_muons_from_b( - pt_min=300.0 * MeV, p_min=3.0 * GeV, mipchi2_min=9.0, pid=(F.PID_MU > -4.0) + pt_min=300.0 * MeV, + p_min=3.0 * GeV, + mipchi2_min=9.0, + pid=F.conditionally_skip((F.PID_MU > -4.0), label="PID"), ) dielectrons = make_detached_dielectron_for_b2lllnu(opposite_sign=False) @@ -333,13 +348,13 @@ def make_b2eeenu_ss(name, process, prescale=1): pt_min=350.0 * MeV, p_min=0.0 * GeV, mipchi2_min=25.0, - pid=(F.PID_E > 0.0), + pid=F.conditionally_skip((F.PID_E > 0.0), label="PID"), require_in_calo=1, ) comb_cut = F.require_all( F.MAX(F.PT) > 500.0 * MeV, - F.MAX(F.PID_E) > 2.0, + F.conditionally_skip(F.MAX(F.PID_E) > 2.0, label="PID"), ) bps = make_b2lllnu( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLNu.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLNu.py index fdeb865d7e9..52cd90f99bb 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLNu.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToLNu.py @@ -71,9 +71,11 @@ def make_veto_for_btomunu(process, fake_mu=False): "Line must be defined as Hlt2 or Sprucing line!" ) muons = ( - make_muons_for_btomunu(pid=(F.PID_MU > 3)) + make_muons_for_btomunu(pid=F.conditionally_skip((F.PID_MU > 3), label="PID")) if not fake_mu - else make_fake_muons_for_btomunu(pid=(F.PID_MU <= 3.0)) + else make_fake_muons_for_btomunu( + pid=F.conditionally_skip((F.PID_MU <= 3.0), label="PID") + ) ) pions = make_pions_for_veto_for_btomunu() @@ -100,7 +102,9 @@ def make_btomunu(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - muons = make_muons_for_btomunu(pid=(F.PID_MU > 3)) + muons = make_muons_for_btomunu( + pid=F.conditionally_skip((F.PID_MU > 3), label="PID") + ) return muons @@ -112,7 +116,9 @@ def make_btomunu_fake_muon(process): assert process in ["hlt2", "spruce"], ( "Line must be defined as Hlt2 or Sprucing line!" ) - muons = make_fake_muons_for_btomunu(pid=(F.PID_MU <= 3.0)) + muons = make_fake_muons_for_btomunu( + pid=F.conditionally_skip((F.PID_MU <= 3.0), label="PID") + ) return muons @@ -128,7 +134,7 @@ def make_prompt_kaons(process): (F.CHILD(2, F.OWNPVIPCHI2) < 2) & (F.CHILD(2, F.PT) > 500) & (F.CHILD(2, F.P) > 5000) - & (F.CHILD(2, F.PID_K) > 5) + & F.conditionally_skip((F.CHILD(2, F.PID_K) > 5), label="PID") & (F.CHILD(2, F.GHOSTPROB) < 0.25) & ( F.ABS diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToTauNu_BTracking.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToTauNu_BTracking.py index 318a9120f7f..a9536e666f9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToTauNu_BTracking.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/HbToTauNu_BTracking.py @@ -29,11 +29,11 @@ B tracking, hence large transverse flight distance requirements and VELO raw ban """ -def make_pions(pid=(F.PID_K < 4)): +def make_pions(pid=F.conditionally_skip((F.PID_K < 4), label="PID")): return base_builder.make_prong_pions(pid=pid) -def make_kaons(pid=(F.PID_K > 4)): +def make_kaons(pid=F.conditionally_skip((F.PID_K > 4), label="PID")): return base_builder.make_kaons(pid=pid) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/base_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/base_builder.py index b8f48e33924..f00afe38b76 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/base_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/base_builder.py @@ -85,7 +85,9 @@ def make_candidate( @configurable -def make_pions(name="SLB_Pion_{hash}", pid=(F.PID_K < 20.0)): +def make_pions( + name="SLB_Pion_{hash}", pid=F.conditionally_skip((F.PID_K < 20.0), label="PID") +): """ Generic pions. """ @@ -97,7 +99,7 @@ def make_prong_pions( name="SLB_ProngPion_{hash}", pt_min=350.0 * MeV, mipchi2_min=15.0, - pid=(F.PID_K < 3.0), + pid=F.conditionally_skip((F.PID_K < 3.0), label="PID"), ): """ Return pions from taus. Cuts from StdLooseDetachedTau3pi @@ -106,7 +108,9 @@ def make_prong_pions( @configurable -def make_kaons(name="SLB_Kaon_{hash}", pid=(F.PID_K > -2.0)): +def make_kaons( + name="SLB_Kaon_{hash}", pid=F.conditionally_skip((F.PID_K > -2.0), label="PID") +): """ Generic kaons. """ @@ -116,7 +120,7 @@ def make_kaons(name="SLB_Kaon_{hash}", pid=(F.PID_K > -2.0)): @configurable def make_kaons_from_b( name="SLB_KaonsFromB_{hash}", - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), p_min=10000 * MeV, pt_min=1000 * MeV, mipchi2_min=36.0, @@ -139,7 +143,7 @@ def make_kaons_from_b( @configurable def make_kaons_from_phi( name="SLB_KaonsFromPhi_{hash}", - pid=(F.PID_K > 5.0), + pid=F.conditionally_skip((F.PID_K > 5.0), label="PID"), p_min=2000 * MeV, pt_min=400 * MeV, mip_min=0.05, @@ -159,7 +163,11 @@ def make_kaons_from_phi( def make_pions_from_b( name="SLB_PionsFromB_{hash}", - pid=F.require_all(F.PID_K < -5.0, F.PID_MU < -5.0, F.PID_P < -5.0), + pid=F.require_all( + F.conditionally_skip(F.PID_K < -5.0, label="PID"), + F.conditionally_skip(F.PID_MU < -5.0, label="PID"), + F.conditionally_skip(F.PID_P < -5.0, label="PID"), + ), p_min=10000 * MeV, pt_min=800 * MeV, mipchi2_min=36.0, @@ -183,7 +191,10 @@ def make_pions_from_b( @configurable def make_protons( name="SLB_Proton_{hash}", - pid=F.require_all(F.PID_P > 0.0, (F.PID_P - F.PID_K) > 0.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 0.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 0.0, label="PID"), + ), ): """ Generic protons. @@ -194,7 +205,10 @@ def make_protons( @configurable def make_protons_from_b( name="SLB_ProtonsFromB_{hash}", - pid=F.require_all(F.PID_P > 10.0, (F.PID_P - F.PID_K) > 10.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 10.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 10.0, label="PID"), + ), p_min=15000 * MeV, pt_min=1000 * MeV, mipchi2_min=16.0, @@ -215,7 +229,10 @@ def make_protons_from_b( @configurable def make_fake_protons_from_b( name="SLB_FakeProtonsFromB_{hash}", - pid=F.require_all(F.PID_P < 10.0, (F.PID_P - F.PID_K) < 10.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P < 10.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) < 10.0, label="PID"), + ), p_min=15000 * MeV, pt_min=1000 * MeV, mipchi2_min=16.0, @@ -259,7 +276,7 @@ def make_muons_from_b( pt_min=1.0 * GeV, mipchi2_min=9.0, mip_min=0, - pid=(F.PID_MU > 0.0), + pid=F.conditionally_skip((F.PID_MU > 0.0), label="PID"), ): """ Muons directly produced in the decay of a b-hadron. @@ -281,7 +298,10 @@ def make_muons_from_b( @configurable def make_muons_for_btomunu( - pid=(F.PID_MU > 3.0), p_min=6000 * MeV, pt_min=1500 * MeV, mipchi2_min=25 + pid=F.conditionally_skip((F.PID_MU > 3.0), label="PID"), + p_min=6000 * MeV, + pt_min=1500 * MeV, + mipchi2_min=25, ): """ Muons produced in the decay b -> Xu mu nu and b -> Xu tau (-> mu nu nu) nu. @@ -296,7 +316,7 @@ def make_fake_muons_for_btomunu( p_min=6000 * MeV, pt_min=1500 * MeV, mipchi2_min=25, - pid=(F.PID_MU <= 3), + pid=F.conditionally_skip((F.PID_MU <= 3), label="PID"), is_decayinflight=False, ): """ @@ -312,7 +332,7 @@ def make_fake_muons_for_btomunu( @configurable def make_electrons_for_btoenu( - pid=(F.PID_E > 3.0), + pid=F.conditionally_skip((F.PID_E > 3.0), label="PID"), eta_cut=(in_range(2.0, F.ETA, 5.0)), p_min=6000 * MeV, pt_min=1000 * MeV, @@ -328,7 +348,7 @@ def make_electrons_for_btoenu( @configurable def make_fake_electrons_for_btoenu( - pid=(F.PID_E <= 3.0), + pid=F.conditionally_skip((F.PID_E <= 3.0), label="PID"), eta_cut=(in_range(2.0, F.ETA, 5.0)), p_min=6000 * MeV, pt_min=1000 * MeV, @@ -358,7 +378,7 @@ def make_electrons_from_b( pt_min=0.5 * GeV, mipchi2_min=9.0, mip_min=0, - pid=(F.PID_E > 0.0), + pid=F.conditionally_skip((F.PID_E > 0.0), label="PID"), eta_cut=None, require_in_calo=0, ): @@ -388,7 +408,7 @@ def make_fake_electrons_from_b_reversedPID( pt_min=0.5 * GeV, mipchi2_min=9.0, eta_cut=None, - pid=(F.PID_E <= 0.0), + pid=F.conditionally_skip((F.PID_E <= 0.0), label="PID"), ): """ 'Fake electrons' directly produced in the decay of a b-hadron. @@ -424,7 +444,7 @@ def make_fake_tauons_electronic_decay( p_min=5.0 * GeV, pt_min=0.5 * GeV, eta_cut=None, - pid=(F.PID_E < 0.0), + pid=F.conditionally_skip((F.PID_E < 0.0), label="PID"), mipchi2_min=16.0, ): """ @@ -443,7 +463,10 @@ def make_fake_tauons_electronic_decay( ## Decays-in-flight @configurable def make_fake_muons_from_b_IsMuon_reversedPID( - pid=(F.PID_MU < 0.0), p_min=6.0 * GeV, pt_min=1.0 * GeV, mipchi2_min=9.0 + pid=F.conditionally_skip((F.PID_MU < 0.0), label="PID"), + p_min=6.0 * GeV, + pt_min=1.0 * GeV, + mipchi2_min=9.0, ): """ 'Fake muons' directly produced in the decay of a b-hadron. @@ -457,7 +480,10 @@ def make_fake_muons_from_b_IsMuon_reversedPID( ## Hadron mis-ID @configurable def make_fake_muons_from_b_notIsMuon_reversedPID( - pid=(F.PID_MU < 2.0), p_min=6.0 * GeV, pt_min=1.0 * GeV, mipchi2_min=9.0 + pid=F.conditionally_skip((F.PID_MU < 2.0), label="PID"), + p_min=6.0 * GeV, + pt_min=1.0 * GeV, + mipchi2_min=9.0, ): """ 'Fake muons' for hadron mis-ID. @@ -465,7 +491,7 @@ def make_fake_muons_from_b_notIsMuon_reversedPID( """ return make_muons_from_b( require_ismuon=0, - pid=F.require_all(pid, ~F.ISMUON), + pid=F.require_all(pid, F.conditionally_skip(~F.ISMUON, label="ISMUON")), p_min=p_min, pt_min=pt_min, mipchi2_min=mipchi2_min, @@ -594,7 +620,7 @@ def make_ks0_ll( pi_ipchi2_min=25.0, pi_p_min=2 * GeV, pi_pt_min=200 * MeV, - pi_pid=F.PID_K < 5, + pi_pid=F.conditionally_skip(F.PID_K < 5, label="PID"), adocachi2cut_max=25.0, bpvvdchi2_min=200.0, # cuts tightened ownpvltime_min=1.0 * ps, @@ -651,7 +677,7 @@ def make_ks0_dd( pi_p_min=2 * GeV, pi_pt_min=250.0 * MeV, pi_ipchi2_min=9, - pi_pid=F.PID_K < 5, + pi_pid=F.conditionally_skip(F.PID_K < 5, label="PID"), adocachi2cut_max=25.0, bpvvdchi2_min=30.0, ownpvfd_min=150 * mm, @@ -709,10 +735,10 @@ def make_lambda_ll( pi_ipchi2_min=25, # in RD WG they have slightly tighter cut of 6 p_p_min=10 * GeV, p_pt_min=200.0 * MeV, # originally 0. - p_pid=F.PID_P > 5.0, + p_pid=F.conditionally_skip(F.PID_P > 5.0, label="PID"), pi_p_min=2 * GeV, pi_pt_min=200.0 * MeV, # originally 0. - pi_pid=F.PID_K < 2, + pi_pid=F.conditionally_skip(F.PID_K < 2, label="PID"), lambda_pt_min=100.0 * MeV, # originally was 0. adocachi2cut_max=25.0, bpvvdchi2_min=200.0, # extra cut in RD WG lines @@ -777,10 +803,10 @@ def make_lambda_dd( pi_ipchi2_min=9, p_p_min=10 * GeV, p_pt_min=600.0 * MeV, - p_pid=F.PID_P > 5.0, + p_pid=F.conditionally_skip(F.PID_P > 5.0, label="PID"), pi_p_min=2 * GeV, pi_pt_min=250.0 * MeV, - pi_pid=F.PID_K < 5, + pi_pid=F.conditionally_skip(F.PID_K < 5, label="PID"), lambda_pt_min=800.0 * MeV, adocachi2cut_max=25.0, bpvvdchi2_min=30.0, @@ -843,7 +869,7 @@ def make_sl_detached_phis( k_p_min=2.0 * GeV, k_pt_min=200.0 * MeV, k_ipchi2_min=9.0, - k_pid=(F.PID_K > 0.0), + k_pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), phi_pt_min=400.0 * MeV, adocachi2cut=30.0, vchi2pdof_max=25.0, @@ -876,7 +902,7 @@ def make_sl_detached_pipi( pi_p_min=2.0 * GeV, pi_pt_min=250.0 * MeV, pi_ipchi2_min=9.0, - pi_pid=(F.PROBNN_PI > 0.5), + pi_pid=F.conditionally_skip((F.PROBNN_PI > 0.5), label="PROBNN"), pipi_pt_min=400.0 * MeV, adocachi2cut=30.0, vchi2pdof_max=9.0, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/charm_hadron_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/charm_hadron_builder.py index 94346e3c342..f87e3ab5aec 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/charm_hadron_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/charm_hadron_builder.py @@ -171,8 +171,8 @@ def make_d0_tokpi( daughter_p_min=None, daughter_pt_min=200.0 * MeV, daughter_mipchi2_min=10.0, - kaon_pid=(F.PID_K > 3.0), - pion_pid=(F.PID_K < 20.0), + kaon_pid=F.conditionally_skip((F.PID_K > 3.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 20.0), label="PID"), ): """ Builder for the decay D0->K+pi-. @@ -213,8 +213,8 @@ def make_dplus_tokpipi( daughter_p_min=5 * GeV, daughter_pt_min=300 * MeV, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), ): """ Builder for the decay D+->K-pi+pi+. @@ -252,8 +252,8 @@ def make_dplus_tokkpi( daughter_p_min=5 * GeV, daughter_pt_min=300 * MeV, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), vchi2pdof_max=4, bpvdira_min=0.999, bpvvdz_min=None, @@ -306,8 +306,8 @@ def make_d0_tok3pi( daughter_p_min=2 * GeV, daughter_pt_min=400.0 * MeV, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 1.0), - pion_pid=(F.PID_K < 8.0), + kaon_pid=F.conditionally_skip((F.PID_K > 1.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 8.0), label="PID"), ): """ Builder for the decay D0->K-pi-pi+pi+. @@ -352,8 +352,8 @@ def make_ds_tokkpi( daughter_p_min=5 * GeV, daughter_pt_min=300 * MeV, daughter_mipchi2_min=9.0, - kaon_pid=(F.PID_K > 4.0), - pion_pid=(F.PID_K < 2.0), + kaon_pid=F.conditionally_skip((F.PID_K > 4.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), vchi2pdof_max=4, bpvdira_min=0.999, bpvvdz_min=None, @@ -446,7 +446,7 @@ def make_jpsi_tomumu( muon_filter = F.require_all(F.PT > mu_pt_min, F.P > mu_p_min) if mu_pid is not None: - muon_filter &= F.PID_MU > mu_pid + muon_filter &= F.conditionally_skip(F.PID_MU > mu_pid, label="PID") if mu_eta_max is not None: muon_filter &= F.ETA < mu_eta_max if mu_mipchi2_min is not None: @@ -500,10 +500,13 @@ def make_lambdac_topkpi( daughter_p_min=2000 * MeV, daughter_pt_min=250 * MeV, daughter_mipchi2_min=6.0, - kaon_pid=(F.PID_K > 2.0), - pion_pid=(F.PID_K < 10.0), + kaon_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 10.0), label="PID"), proton_p_min=10000 * MeV, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Lambda_c+ -> p+ K- pi+. @@ -560,7 +563,7 @@ def make_lambdac_tolambda0pi( daughter_pt_min=400 * MeV, daughter_trghostprob_max=0.4, daughter_mipchi2_min=16.0, - pion_pid=(F.PID_K < 5.0), + pion_pid=F.conditionally_skip((F.PID_K < 5.0), label="PID"), ): """ Builder for the decay Lambda_c+ -> p+ Lambda0(->p pi-). @@ -625,7 +628,10 @@ def make_lambdac_topks( daughter_pt_min=400 * MeV, daughter_trghostprob_max=0.4, daughter_mipchi2_min=16.0, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Lambda_c+ -> p KS0(->pi+ pi-). @@ -689,9 +695,12 @@ def make_lambdac_topphi( daughter_pt_min=400 * MeV, daughter_trghostprob_max=0.4, daughter_mipchi2_min=16.0, - kaon_pid=(F.PID_K > 3.0), + kaon_pid=F.conditionally_skip((F.PID_K > 3.0), label="PID"), proton_p_min=10000 * MeV, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Lambda_c+ -> p PHI @@ -745,7 +754,10 @@ def make_lambdac_toppipi( daughter_trghostprob_max=0.4, daughter_mipchi2_min=16.0, proton_p_min=10000 * MeV, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Lambda_c+ -> p PHI @@ -796,10 +808,13 @@ def make_xicplus_topkpi( common_daug_p_min=2000 * MeV, common_daug_pt_min=250 * MeV, common_daug_mipchi2_min=6.0, - kaon_pid=(F.PID_K > 2.0), - pion_pid=(F.PID_K < 10.0), + kaon_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 10.0), label="PID"), proton_p_min=10000 * MeV, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Xi_c+ -> p+ K- pi+. @@ -859,10 +874,13 @@ def make_xic0_topkkpi( common_daug_p_min=2000 * MeV, common_daug_pt_min=250 * MeV, common_daug_mipchi2_min=6.0, - kaon_pid=(F.PID_K > 2.0), - pion_pid=(F.PID_K < 10.0), + kaon_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 10.0), label="PID"), proton_p_min=10000 * MeV, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Xi_c0 -> p+ K- K- pi+. @@ -923,10 +941,13 @@ def make_omegac_topkkpi( daughter_p_min=2000.0 * MeV, daughter_pt_min=250.0 * MeV, daughter_mipchi2_min=6.0, - kaon_pid=(F.PID_K > 2.0), - pion_pid=(F.PID_K < 10.0), + kaon_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), + pion_pid=F.conditionally_skip((F.PID_K < 10.0), label="PID"), proton_p_min=10000 * MeV, - proton_pid=F.require_all(F.PID_P > 5.0, (F.PID_P - F.PID_K) > 2.0), + proton_pid=F.require_all( + F.conditionally_skip(F.PID_P > 5.0, label="PID"), + F.conditionally_skip((F.PID_P - F.PID_K) > 2.0, label="PID"), + ), ): """ Builder for the decay Omega_c0 -> p+ K- K- pi+. diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/dilepton_builder.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/dilepton_builder.py index dd8209d8196..a6c86b39b5c 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/dilepton_builder.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/semileptonic/builders/dilepton_builder.py @@ -54,7 +54,7 @@ def make_detached_dimuon_for_b2lllnu( pt_min=pt_muon_min, p_min=p_muon_min, mipchi2_min=ipchi2_muon_min, - pid=(F.PID_MU > pidmu_muon_min), + pid=F.conditionally_skip((F.PID_MU > pidmu_muon_min), label="PID"), ) DecayDescriptor = f"{parent_id} -> mu+ mu-" diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/hlt2_test.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/hlt2_test.py index 938340fb375..b3b8821a18a 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/hlt2_test.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/hlt2_test.py @@ -99,8 +99,8 @@ def filtered_photons_line(name="Hlt2Test_FilteredPhotons", prescale=1): photons = make_photons() code = F.require_all( F.P > 40 * GeV, - F.IS_PHOTON > 0.5, - F.IS_NOT_H > 0.3, + F.conditionally_skip(F.IS_PHOTON > 0.5, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.3, label="IS_NOT_H"), F.CALO_NEUTRAL_SHOWER_SHAPE < 1500, ) line_alg = ParticleFilter(Input=photons, Cut=F.FILTER(code)) @@ -159,8 +159,8 @@ def sRT_photons_line(name="Hlt2Test_sRTPhotons", prescale=1): photons = FilterRelTable(InputTable=relTab, Predicate=predicateCut).OutputLocation code = F.require_all( F.P > 40 * GeV, - F.IS_PHOTON > 0.5, - F.IS_NOT_H > 0.3, + F.conditionally_skip(F.IS_PHOTON > 0.5, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.3, label="IS_NOT_H"), ) line_alg = ParticleFilter(photons, F.FILTER(code)) return Hlt2Line(name=name, prescale=prescale, algs=[line_alg]) @@ -169,7 +169,11 @@ def sRT_photons_line(name="Hlt2Test_sRTPhotons", prescale=1): # From Hlt2Conf/lines/monitoring/pi0_line.py @register_line_builder(hlt2_test_lines) def pi0_to_gammagamma_line(name="Hlt2Test_Pi0ToGammaGamma", prescale=1): - code = F.require_all(F.PT > 250 * MeV, F.P > 2 * GeV, F.IS_NOT_H > 0.2) + code = F.require_all( + F.PT > 250 * MeV, + F.P > 2 * GeV, + F.conditionally_skip(F.IS_NOT_H > 0.2, label="IS_NOT_H"), + ) photons = ParticleFilter(Input=make_photons(), Cut=F.FILTER(code)) combination_code = F.require_all( @@ -194,7 +198,13 @@ def xicz_to_lpipi_dd_line(name="Hlt2Test_Xic0ToL0PimPip_DD"): down_pions = ParticleFilter(make_down_pions(), F.FILTER(F.PT > 180 * MeV)) down_protons = ParticleFilter( make_has_rich_down_protons(), - F.FILTER(F.require_all(F.PT > 700 * MeV, F.P > 10 * GeV, F.PID_P > -5.0)), + F.FILTER( + F.require_all( + F.PT > 700 * MeV, + F.P > 10 * GeV, + F.conditionally_skip(F.PID_P > -5.0, label="PID"), + ) + ), ) dd_lambdas = ParticleCombiner( [down_protons, down_pions], @@ -219,7 +229,10 @@ def xicz_to_lpipi_dd_line(name="Hlt2Test_Xic0ToL0PimPip_DD"): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 400 * MeV, F.P > 3 * GeV, _MIPCHI2_MIN(6.0), F.PID_K < 5.0 + F.PT > 400 * MeV, + F.P > 3 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -267,7 +280,10 @@ def oc_to_ximkpipi_lll_line(name="Hlt2Test_Oc0ToXimKmPipPip_LLL"): make_has_rich_long_protons(), F.FILTER( F.require_all( - F.PT > 400 * MeV, F.P > 9 * GeV, _MIPCHI2_MIN(6.0), F.PID_P > -5.0 + F.PT > 400 * MeV, + F.P > 9 * GeV, + _MIPCHI2_MIN(6.0), + F.conditionally_skip(F.PID_P > -5.0, label="PID"), ) ), ) @@ -313,7 +329,10 @@ def oc_to_ximkpipi_lll_line(name="Hlt2Test_Oc0ToXimKmPipPip_LLL"): make_has_rich_long_kaons(), F.FILTER( F.require_all( - F.PT > 400 * MeV, F.P > 5 * GeV, _MIPCHI2_MIN(3.0), F.PID_K > 0.0 + F.PT > 400 * MeV, + F.P > 5 * GeV, + _MIPCHI2_MIN(3.0), + F.conditionally_skip(F.PID_K > 0.0, label="PID"), ), ), ) @@ -321,7 +340,10 @@ def oc_to_ximkpipi_lll_line(name="Hlt2Test_Oc0ToXimKmPipPip_LLL"): make_has_rich_long_pions(), F.FILTER( F.require_all( - F.PT > 250 * MeV, F.P > 2 * GeV, _MIPCHI2_MIN(3.0), F.PID_K < 5.0 + F.PT > 250 * MeV, + F.P > 2 * GeV, + _MIPCHI2_MIN(3.0), + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -369,7 +391,9 @@ def oc_to_ximkpipi_lll_line(name="Hlt2Test_Oc0ToXimKmPipPip_LLL"): def _make_phi(): kaons = make_long_kaons() filteredKaons = ParticleFilter( - name="FilteredPIDkaons", Input=kaons, Cut=F.FILTER(F.PID_K > -5) + name="FilteredPIDkaons", + Input=kaons, + Cut=F.FILTER(F.conditionally_skip(F.PID_K > -5, label="PID")), ) combination_code = F.require_all( F.math.in_range(980.0 * MeV, F.MASS, 1060.0 * MeV), @@ -431,7 +455,9 @@ def bs2jpsiphi_jpsi2mumu_phi2kk_line( # mstahl: (almost) all production lines should use make_ismuon_long_muon instead of make_long_muons muons = make_long_muons() filteredMuons = ParticleFilter( - name="FilteredPIDMuons", Input=muons, Cut=F.FILTER(F.PID_MU > 0.0) + name="FilteredPIDMuons", + Input=muons, + Cut=F.FILTER(F.conditionally_skip(F.PID_MU > 0.0, label="PID")), ) mother_code = F.CHI2 < 16.0 combination_code = F.require_all( @@ -482,7 +508,9 @@ def bs2jpsiphi_jpsi2mumu_phi2kk_pvunbiasing_with_refit_line( # mstahl: (almost) all production lines should use make_ismuon_long_muon instead of make_long_muons muons = make_long_muons() filteredMuons = ParticleFilter( - name="FilteredPIDMuons", Input=muons, Cut=F.FILTER(F.PID_MU > 0.0) + name="FilteredPIDMuons", + Input=muons, + Cut=F.FILTER(F.conditionally_skip(F.PID_MU > 0.0, label="PID")), ) mother_code = F.CHI2 < 16.0 combination_code = F.require_all( @@ -524,7 +552,9 @@ def bs2jpsiphi_jpsi2mumu_phi2kk_pvunbiasing_line( # mstahl: (almost) all production lines should use make_ismuon_long_muon instead of make_long_muons muons = make_long_muons() filteredMuons = ParticleFilter( - name="FilteredPIDMuons", Input=muons, Cut=F.FILTER(F.PID_MU > 0.0) + name="FilteredPIDMuons", + Input=muons, + Cut=F.FILTER(F.conditionally_skip(F.PID_MU > 0.0, label="PID")), ) mother_code = F.CHI2 < 16.0 combination_code = F.require_all( @@ -565,7 +595,9 @@ def bs2jpsiphi_jpsi2ee_phi2kk_line( pvs = make_pvs() electrons = make_long_electrons_with_brem() filteredElectrons = ParticleFilter( - name="FilteredPIDElectrons", Input=electrons, Cut=F.FILTER(F.PID_E > 0.0) + name="FilteredPIDElectrons", + Input=electrons, + Cut=F.FILTER(F.conditionally_skip(F.PID_E > 0.0, label="PID")), ) mother_code = F.CHI2 < 16.0 combination_code = F.require_all( @@ -609,7 +641,10 @@ def make_jpsi( max_vchi2pdof=10, ): muon_code = F.require_all( - F.ISMUON, F.PT > minPt_muon, F.P > minP_muon, F.PID_MU > minPIDmu + F.ISMUON, + F.PT > minPt_muon, + F.P > minP_muon, + F.conditionally_skip(F.PID_MU > minPIDmu, label="PID"), ) muons = ParticleFilter( @@ -645,7 +680,7 @@ def make_detached_kaons( eta_min=2.0, eta_max=5.0, mipchi2dvprimary_min=0, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): pvs = make_pvs() @@ -818,7 +853,7 @@ def _make_dstars(dzeros, decay_descriptor, name): F.require_all( F.PT > 150 * MeV, F.P > 1 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ), ), ) @@ -859,7 +894,7 @@ def _make_dzeros(pvs): _MIPCHI2_MIN(4.0), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ), ), ) @@ -924,7 +959,7 @@ def b2d0mu_dzero2kpkm_line(name="Hlt2Test_BToD0MumX_D0ToKpKm", prescale=1): F.MINIPCHI2CUT(IPChi2Cut=9.0, Vertices=pvs), F.PT > 1 * GeV, F.P > 2 * GeV, - F.PID_MU > 0.0, + F.conditionally_skip(F.PID_MU > 0.0, label="PID"), ), ), ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/spruce_test.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/spruce_test.py index fb7e97ee984..dcc2d3bd1d1 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/spruce_test.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/test/spruce_test.py @@ -65,7 +65,7 @@ def make_test_has_rich_detached_pions( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K <= 0.0), + pid=F.conditionally_skip((F.PID_K <= 0.0), label="PID"), ): """ Return RD detached pions with hasRich. @@ -85,7 +85,7 @@ def make_test_has_rich_detached_kaons( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): """ Return detached kaons with hasRich. @@ -111,11 +111,11 @@ def make_test_detached_kstar0s( # if the RICH can not distinguish between kaons and pions then # the PID will be set to zero, and most often these will correspond # to real pions - pi_pid=F.PID_K < 1e-5, + pi_pid=F.conditionally_skip(F.PID_K < 1e-5, label="PID"), k_p_min=2.0 * GeV, k_pt_min=250.0 * MeV, k_ipchi2_min=9.0, - k_pid=(F.PID_K > 2.0), + k_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), kstar0_pt_min=400.0 * MeV, adocachi2cut=30.0, maxdoca=0.5 * mm, @@ -170,8 +170,8 @@ def make_test_photons( code = F.require_all( F.PT > et_min, F.P > e_min, - F.IS_PHOTON > IsPhoton_min, - F.IS_NOT_H > IsNotH_min, + F.conditionally_skip(F.IS_PHOTON > IsPhoton_min, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > IsNotH_min, label="IS_NOT_H"), F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > E19_min, ) return ParticleFilter(make_particles(), F.FILTER(code), name=name) @@ -220,7 +220,7 @@ def b2kstgamma_line(): k_pt_min=500.0 * MeV, k_ipchi2_min=11.0, pi_ipchi2_min=11.0, - k_pid=(F.PID_K > 0.0), + k_pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), kstar0_pt_min=1500.0 * MeV, vchi2pdof_max=15.0, am_min=705.0 * MeV, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/DiMuonTrackEfficiency.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/DiMuonTrackEfficiency.py index 50707a4b245..e56f96b1ed9 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/DiMuonTrackEfficiency.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/DiMuonTrackEfficiency.py @@ -190,7 +190,7 @@ def make_TagFilter( F.P > get_cuts["min_TagP"], F.PT > get_cuts["min_TagPT"], F.ISMUON(), - F.PID_MU > get_cuts["min_TagMuonID"], + F.conditionally_skip(F.PID_MU > get_cuts["min_TagMuonID"], label="PID"), F.GHOSTPROB() < get_cuts["max_TagGhostProb"], ) if get_cuts["min_TagIP"] is not None: diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/JpsiToMuMu_PVTracks.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/JpsiToMuMu_PVTracks.py index e703177ca44..388ed2147ca 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/JpsiToMuMu_PVTracks.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/JpsiToMuMu_PVTracks.py @@ -1,91 +1,91 @@ -############################################################################### -# (c) Copyright 2021-2025 CERN for the benefit of the LHCb Collaboration # -# # -# This software is distributed under the terms of the GNU General Public # -# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # -# # -# In applying this licence, CERN does not waive the privileges and immunities # -# granted to it by virtue of its status as an Intergovernmental Organization # -# or submit itself to any jurisdiction. # -############################################################################### - -import Functors as F -from GaudiKernel.SystemOfUnits import MeV -from Moore.config import Hlt2Line, register_line_builder -from PyConf import configurable -from RecoConf.algorithms_thor import ParticleCombiner, ParticleFilter -from RecoConf.standard_particles import make_ismuon_long_muon - -_MASSWINDOW_LOW_JPSI_ = 150 * MeV -_MASSWINDOW_HIGH_JPSI_ = 150 * MeV -_JPSI_PDG_MASS_ = 3096.9 * MeV - -_MASSMIN_JPSI = _JPSI_PDG_MASS_ - _MASSWINDOW_LOW_JPSI_ -_MASSMAX_JPSI = _JPSI_PDG_MASS_ + _MASSWINDOW_HIGH_JPSI_ - -all_lines = {} - - -@configurable -def make_charmonium_muons( - make_particles=make_ismuon_long_muon, - name="charmonium_muons_{hash}", - minPt_muon=300 * MeV, - minPID_mu=2, - maxGhostProb=0.7, -): - code = F.require_all( - F.ISMUON, - F.PT > minPt_muon, - F.PID_MU > minPID_mu, - F.PROBNN_GHOST < maxGhostProb, - ) - - muons = ParticleFilter(make_particles(), Cut=F.FILTER(code)) - return muons - - -@configurable -def make_Jpsi( - muons, - maxVertexChi2=25, - minMass_dimuon=_MASSMIN_JPSI, - maxMass_dimuon=_MASSMAX_JPSI, -): - muons = make_charmonium_muons() - vertex_code = F.require_all(F.CHI2DOF < maxVertexChi2) - combination_code = F.require_all( - F.MASS > minMass_dimuon, - F.MASS < maxMass_dimuon, - ) - - line_alg = ParticleCombiner( - name="Jpsi_combiner_{hash}", - DecayDescriptor="J/psi(1S) -> mu+ mu-", - Inputs=[muons, muons], - CombinationCut=combination_code, - CompositeCut=vertex_code, - ) - return line_alg - - -@register_line_builder(all_lines) -@configurable -def make_JpsiToMuMu_PVTracks( - name="Hlt2_JpsiToMuMu_PVTracks", - prescale=0.05, - persistreco=True, - pv_tracks=True, - raw_banks=["VP"], -): - muons = make_charmonium_muons() - line_alg = make_Jpsi(muons=muons) - - return Hlt2Line( - name=name, - prescale=prescale, - algs=[line_alg], - persistreco=persistreco, - pv_tracks=pv_tracks, - raw_banks=raw_banks, - ) +############################################################################### +# (c) Copyright 2021-2025 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### + +import Functors as F +from GaudiKernel.SystemOfUnits import MeV +from Moore.config import Hlt2Line, register_line_builder +from PyConf import configurable +from RecoConf.algorithms_thor import ParticleCombiner, ParticleFilter +from RecoConf.standard_particles import make_ismuon_long_muon + +_MASSWINDOW_LOW_JPSI_ = 150 * MeV +_MASSWINDOW_HIGH_JPSI_ = 150 * MeV +_JPSI_PDG_MASS_ = 3096.9 * MeV + +_MASSMIN_JPSI = _JPSI_PDG_MASS_ - _MASSWINDOW_LOW_JPSI_ +_MASSMAX_JPSI = _JPSI_PDG_MASS_ + _MASSWINDOW_HIGH_JPSI_ + +all_lines = {} + + +@configurable +def make_charmonium_muons( + make_particles=make_ismuon_long_muon, + name="charmonium_muons_{hash}", + minPt_muon=300 * MeV, + minPID_mu=2, + maxGhostProb=0.7, +): + code = F.require_all( + F.ISMUON, + F.PT > minPt_muon, + F.conditionally_skip(F.PID_MU > minPID_mu, label="PID"), + F.conditionally_skip(F.PROBNN_GHOST < maxGhostProb, label="PROBNN"), + ) + + muons = ParticleFilter(make_particles(), Cut=F.FILTER(code)) + return muons + + +@configurable +def make_Jpsi( + muons, + maxVertexChi2=25, + minMass_dimuon=_MASSMIN_JPSI, + maxMass_dimuon=_MASSMAX_JPSI, +): + muons = make_charmonium_muons() + vertex_code = F.require_all(F.CHI2DOF < maxVertexChi2) + combination_code = F.require_all( + F.MASS > minMass_dimuon, + F.MASS < maxMass_dimuon, + ) + + line_alg = ParticleCombiner( + name="Jpsi_combiner_{hash}", + DecayDescriptor="J/psi(1S) -> mu+ mu-", + Inputs=[muons, muons], + CombinationCut=combination_code, + CompositeCut=vertex_code, + ) + return line_alg + + +@register_line_builder(all_lines) +@configurable +def make_JpsiToMuMu_PVTracks( + name="Hlt2_JpsiToMuMu_PVTracks", + prescale=0.05, + persistreco=True, + pv_tracks=True, + raw_banks=["VP"], +): + muons = make_charmonium_muons() + line_alg = make_Jpsi(muons=muons) + + return Hlt2Line( + name=name, + prescale=prescale, + algs=[line_alg], + persistreco=persistreco, + pv_tracks=pv_tracks, + raw_banks=raw_banks, + ) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/KSVeloLong.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/KSVeloLong.py index d9ed401cf97..d76f8e0aac4 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/KSVeloLong.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/KSVeloLong.py @@ -98,7 +98,7 @@ def filter_pions(particles, pvs=None, pt_min=0.4 * GeV, fromSMOG2=False): cut &= F.P > 2000 else: cut &= F.P > 5000 - cut &= F.PID_P < 5 + cut &= F.conditionally_skip(F.PID_P < 5, label="PID") cut &= F.MINIP(pvs) > 0.4 * mm return ParticleFilter(particles, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/SMOG2_Jpsi_trackeff.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/SMOG2_Jpsi_trackeff.py index e68e15508d1..fb12a5a056a 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/SMOG2_Jpsi_trackeff.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/SMOG2_Jpsi_trackeff.py @@ -178,7 +178,7 @@ def make_TagFilter( F.P > get_cuts["min_TagP"], F.PT > get_cuts["min_TagPT"], F.ISMUON(), - F.PID_MU > get_cuts["min_TagMuonID"], + F.conditionally_skip(F.PID_MU > get_cuts["min_TagMuonID"], label="PID"), F.GHOSTPROB() < get_cuts["max_TagGhostProb"], ) return ParticleFilter(particles, F.FILTER(code), name=name) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_ElectronProbe.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_ElectronProbe.py index 3336979f2e1..20722d2466f 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_ElectronProbe.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_ElectronProbe.py @@ -144,7 +144,7 @@ def filter_TagKaons( F.PT > min_pt, F.CHI2DOF < max_trchi2dof, F.MINIPCHI2(pvs) > min_ipchi2, - F.PID_K > min_pid, + F.conditionally_skip(F.PID_K > min_pid, label="PID"), F.ETA > min_eta, F.ETA < max_eta, F.P > min_p, @@ -172,7 +172,7 @@ def filter_TagElectrons( F.PT > min_pt, F.CHI2DOF < max_trchi2dof, F.MINIPCHI2(pvs) > min_ipchi2, - F.PID_E > min_pid, + F.conditionally_skip(F.PID_E > min_pid, label="PID"), F.P > min_p, F.ETA < max_eta, F.ETA > min_eta, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_MuonProbe.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_MuonProbe.py index f5846e9abee..13ed1452230 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_MuonProbe.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_B2JpsiK_MuonProbe.py @@ -149,7 +149,7 @@ def filter_TagKaons( F.PT > min_pt, F.CHI2DOF < max_trchi2dof, F.MINIPCHI2(pvs) > min_ipchi2, - F.PID_K > min_pid, + F.conditionally_skip(F.PID_K > min_pid, label="PID"), F.ETA > min_eta, F.ETA < max_eta, F.P > min_p, @@ -177,7 +177,7 @@ def filter_TagMuons( F.PT > min_pt, F.CHI2DOF < max_trchi2dof, F.MINIPCHI2(pvs) > min_ipchi2, - F.PID_MU > min_pid, + F.conditionally_skip(F.PID_MU > min_pid, label="PID"), F.ISMUON(), F.P > min_p, F.ETA < max_eta, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_Ds2PhiPi_KaonProbe.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_Ds2PhiPi_KaonProbe.py index 8d015e99bd4..7291cdbe978 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_Ds2PhiPi_KaonProbe.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_Ds2PhiPi_KaonProbe.py @@ -63,8 +63,8 @@ def filter_tag_kaons( code = F.require_all( F.PT > min_pt, F.MINIPCHI2(pvs) > min_ipchi2, - F.PID_K > min_pid, - (F.PID_K - F.PID_P) > min_pid_wrt_proton, + F.conditionally_skip(F.PID_K > min_pid, label="PID"), + F.conditionally_skip((F.PID_K - F.PID_P) > min_pid_wrt_proton, label="PID"), F.ETA > min_eta, F.ETA < max_eta, F.P > min_p, @@ -90,8 +90,8 @@ def filter_tag_pions( code = F.require_all( F.PT > min_pt, F.MINIPCHI2(pvs) > min_ipchi2, - F.PID_K < max_pid_k, - F.PID_MU < max_pid_mu, + F.conditionally_skip(F.PID_K < max_pid_k, label="PID"), + F.conditionally_skip(F.PID_MU < max_pid_mu, label="PID"), F.ETA > min_eta, F.ETA < max_eta, F.P > min_p, diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_L2PPi_ProtonProbe.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_L2PPi_ProtonProbe.py index 0342de678d3..e918bbcdf97 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_L2PPi_ProtonProbe.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/Velo2Long_L2PPi_ProtonProbe.py @@ -108,7 +108,7 @@ def filter_pions(particles, pvs=None, pt_min=0.4 * GeV, fromSMOG2=False): cut &= F.P > 2000 else: cut &= F.P > 5000 - cut &= F.PID_P < 5 + cut &= F.conditionally_skip(F.PID_P < 5, label="PID") cut &= F.MINIP(pvs) > 0.4 * mm return ParticleFilter(particles, F.FILTER(cut)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/ZUpsilonFullEvent.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/ZUpsilonFullEvent.py index ec1aa8fdd7e..65acc6325e0 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/ZUpsilonFullEvent.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/trackeff/ZUpsilonFullEvent.py @@ -77,7 +77,7 @@ def make_dimuon_candidates( combination_cuts = F.require_all( in_range(min_mass, F.MASS, max_mass), - F.MAX(F.PID_MU) > min_maxpidmu, + F.conditionally_skip(F.MAX(F.PID_MU) > min_maxpidmu, label="PID"), F.SDOCA(1, 2) < max_doca, ) vertex_code = F.require_all(F.CHI2DOF < vchi2pdof_max) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_beauty_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_beauty_hlt2.py index ad5283cac19..5fa72706600 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_beauty_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_beauty_hlt2.py @@ -53,7 +53,7 @@ def Hlt2TriggerEff_BuToJpsiKplus_JpsiToMuMu_B2CC_line( F.PT > 500.0 * MeV, F.P > 0 * MeV, F.MINIPCHI2(make_pvs()) > 0, - F.PID_MU > -5, + F.conditionally_skip(F.PID_MU > -5, label="PID"), F.ISMUON, F.ETA < 5.0, ) @@ -80,7 +80,7 @@ def Hlt2TriggerEff_BuToJpsiKplus_JpsiToMuMu_B2CC_line( filter_kaons = ( require_all(F.PT > 800 * MeV, F.P > 3000 * MeV) & (F.MINIPCHI2(make_pvs()) > 0) - & (F.PID_K > -1) + & F.conditionally_skip((F.PID_K > -1), label="PID") ) kplus = ParticleFilter(make_has_rich_long_kaons(), F.FILTER(filter_kaons)) @@ -145,7 +145,10 @@ def Hlt2TriggerEff_BuToJpsiKplus_JpsiToMuMu_RD_line( ): kaon_pvs = make_pvs() kaon_cuts = F.require_all( - F.PT > 250.0 * MeV, F.P > 2.0 * GeV, F.PID_K > 2, F.MINIPCHI2(kaon_pvs) > 9 + F.PT > 250.0 * MeV, + F.P > 2.0 * GeV, + F.conditionally_skip(F.PID_K > 2, label="PID"), + F.MINIPCHI2(kaon_pvs) > 9, ) kaons = ParticleFilter( make_long_kaons(), @@ -157,7 +160,7 @@ def Hlt2TriggerEff_BuToJpsiKplus_JpsiToMuMu_RD_line( F.PT > 300.0 * MeV, F.P > 3000.0 * MeV, F.ISMUON, - F.PID_MU > 3, + F.conditionally_skip(F.PID_MU > 3, label="PID"), F.MINIPCHI2(muon_pvs) > 9, ) muon = ParticleFilter( diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_charm_hlt2.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_charm_hlt2.py index c3ed0d666e4..f14af62d4f0 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_charm_hlt2.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/triggereff/triggereff_charm_hlt2.py @@ -43,7 +43,7 @@ def Hlt2TriggerEff_Dstp2D0Pip_D02KmPip_line(name="Hlt2TriggerEff_Dstp2D0Pip_D02K F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K > 5.0, + F.conditionally_skip(F.PID_K > 5.0, label="PID"), ) kaons = ParticleFilter(make_has_rich_long_kaons(), F.FILTER(kaons_cuts)) @@ -51,7 +51,7 @@ def Hlt2TriggerEff_Dstp2D0Pip_D02KmPip_line(name="Hlt2TriggerEff_Dstp2D0Pip_D02K F.MINIPCHI2CUT(IPChi2Cut=4.0, Vertices=make_pvs()), F.PT > 800 * MeV, F.P > 5 * GeV, - F.PID_K < 5.0, + F.conditionally_skip(F.PID_K < 5.0, label="PID"), ) pions = ParticleFilter(make_has_rich_long_pions(), F.FILTER(pions_cuts)) diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py b/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py index c43f6cd925e..4bce9e09952 100644 --- a/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py +++ b/Hlt/Hlt2Conf/python/Hlt2Conf/settings/hlt2_slim.py @@ -55,8 +55,8 @@ def _filter_photons(): F.require_all( F.PT > 200 * MeV, F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > 0.85, - F.IS_PHOTON > 0.7, - F.IS_NOT_H > 0.4, + F.conditionally_skip(F.IS_PHOTON > 0.7, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.4, label="IS_NOT_H"), ) ), ) diff --git a/Hlt/Hlt2Conf/tests/options/bandwidth/spruce_bandwidth_PbPb_lumi_streams.py b/Hlt/Hlt2Conf/tests/options/bandwidth/spruce_bandwidth_PbPb_lumi_streams.py index 418cf6be740..ad9ccd8d306 100644 --- a/Hlt/Hlt2Conf/tests/options/bandwidth/spruce_bandwidth_PbPb_lumi_streams.py +++ b/Hlt/Hlt2Conf/tests/options/bandwidth/spruce_bandwidth_PbPb_lumi_streams.py @@ -25,6 +25,7 @@ from Moore.lines import PassLine from Moore.monitoring import run_default_monitoring from Moore.streams import Stream, Streams from RecoConf.reconstruction_objects import reconstruction + from scripts.helperfunctions import run_moore_nofilter log = logging.getLogger() diff --git a/Hlt/Hlt2Conf/tests/options/hlt2_combinations_particle_v2.py b/Hlt/Hlt2Conf/tests/options/hlt2_combinations_particle_v2.py index df525b1a3df..e738ef3ee1b 100644 --- a/Hlt/Hlt2Conf/tests/options/hlt2_combinations_particle_v2.py +++ b/Hlt/Hlt2Conf/tests/options/hlt2_combinations_particle_v2.py @@ -34,7 +34,7 @@ def filter_kaons(particles, pvs, pt_min=0.5 * GeV, mipchi2_min=9, dllk_min=+0.5) cut = F.require_all( F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_K > dllk_min, + F.conditionally_skip(F.PID_K > dllk_min, label="PID"), ) return ChargedBasicsFilter(Input=particles, Cut=F.FILTER(cut)).Output @@ -43,7 +43,7 @@ def filter_pions(particles, pvs, pt_min=0.5 * GeV, mipchi2_min=9, dllk_max=-0.5) cut = F.require_all( F.PT > pt_min, F.MINIPCHI2(pvs) > mipchi2_min, - F.PID_K < dllk_max, + F.conditionally_skip(F.PID_K < dllk_max, label="PID"), ) return ChargedBasicsFilter(Input=particles, Cut=F.FILTER(cut)).Output diff --git a/Hlt/Hlt2Conf/tests/options/test_bremsstrahlung.py b/Hlt/Hlt2Conf/tests/options/test_bremsstrahlung.py index 8a259c36b03..ef8a084c1d7 100644 --- a/Hlt/Hlt2Conf/tests/options/test_bremsstrahlung.py +++ b/Hlt/Hlt2Conf/tests/options/test_bremsstrahlung.py @@ -78,7 +78,10 @@ def filter_kaons( pidCut=0, mipChi2Cut=4, ): - code = F.require_all(F.PID_K > pidCut, F.MINIPCHI2(pvs) > mipChi2Cut) + code = F.require_all( + F.conditionally_skip(F.PID_K > pidCut, label="PID"), + F.MINIPCHI2(pvs) > mipChi2Cut, + ) return ParticleFilter(kaons, F.FILTER(code), name=name) diff --git a/Hlt/RecoConf/options/hlt2_particles_baseline.py b/Hlt/RecoConf/options/hlt2_particles_baseline.py index 650e94994cc..97707c29ae4 100644 --- a/Hlt/RecoConf/options/hlt2_particles_baseline.py +++ b/Hlt/RecoConf/options/hlt2_particles_baseline.py @@ -76,7 +76,7 @@ def standalone_hlt2_particles(print_protos=False): F.require_all( F.PT > 500 * MeV, F.P > 2000.0 * MeV, - F.PID_K < 0, + F.conditionally_skip(F.PID_K < 0, label="PID"), F.BPVIPCHI2(pvs()) > 9, ) ), @@ -86,7 +86,13 @@ def standalone_hlt2_particles(print_protos=False): long_muons = ParticleFilter( Input=muons, name="filter_muons", - Cut=F.FILTER(F.require_all(F.PT > 200.0 * MeV, F.ISMUON, F.PROBNN_MU > 0.5)), + Cut=F.FILTER( + F.require_all( + F.PT > 200.0 * MeV, + F.ISMUON, + F.conditionally_skip(F.PROBNN_MU > 0.5, label="PROBNN"), + ) + ), ) ksll = make_KsLL(long_detached_pions) diff --git a/Hlt/RecoConf/python/RecoConf/monitoring_particles.py b/Hlt/RecoConf/python/RecoConf/monitoring_particles.py index 0e1afbcd91a..99d2ff64712 100644 --- a/Hlt/RecoConf/python/RecoConf/monitoring_particles.py +++ b/Hlt/RecoConf/python/RecoConf/monitoring_particles.py @@ -46,8 +46,8 @@ def _filter_photons(for_piz=False): F.require_all( F.PT > 300 * MeV, F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > 0.7, - F.IS_PHOTON > 0.8, - F.IS_NOT_H > 0.7, + F.conditionally_skip(F.IS_PHOTON > 0.8, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.7, label="IS_NOT_H"), ) ) @@ -57,8 +57,8 @@ def _filter_photons(for_piz=False): F.require_all( F.PT > 300 * MeV, F.CALO_NEUTRAL_1TO9_ENERGY_RATIO > 0.7, - F.IS_PHOTON > 0.6, - F.IS_NOT_H > 0.4, + F.conditionally_skip(F.IS_PHOTON > 0.6, label="IS_PHOTON"), + F.conditionally_skip(F.IS_NOT_H > 0.4, label="IS_NOT_H"), ) ) @@ -71,14 +71,24 @@ def _filter_photons(for_piz=False): def _filter_long_pions_for_strange(): return ParticleFilter( make_has_rich_long_pions(), - F.FILTER(F.require_all(F.PT > 80 * MeV, F.OWNPVIPCHI2 > 9.0, F.PID_K < 5)), + F.FILTER( + F.require_all( + F.PT > 80 * MeV, + F.OWNPVIPCHI2 > 9.0, + F.conditionally_skip(F.PID_K < 5, label="PID"), + ) + ), ) def _filter_down_pions_for_strange(): return ParticleFilter( make_has_rich_down_pions(), - F.FILTER(F.require_all(F.PT > 100 * MeV, F.PID_K < 10)), + F.FILTER( + F.require_all( + F.PT > 100 * MeV, F.conditionally_skip(F.PID_K < 10, label="PID") + ) + ), ) @@ -93,7 +103,10 @@ def _filter_long_protons_for_strange(): make_has_rich_long_protons(), F.FILTER( F.require_all( - F.PT > 350 * MeV, F.P > 2.3 * GeV, F.OWNPVIPCHI2 > 6.0, F.PID_P > 3 + F.PT > 350 * MeV, + F.P > 2.3 * GeV, + F.OWNPVIPCHI2 > 6.0, + F.conditionally_skip(F.PID_P > 3, label="PID"), ) ), ) @@ -105,7 +118,7 @@ def _filter_long_pions_for_charm(): F.FILTER( F.require_all( F.PT > 180 * MeV, - F.PID_K < 3.0, + F.conditionally_skip(F.PID_K < 3.0, label="PID"), F.OWNPVIPCHI2 > 6.0, ), ), @@ -115,7 +128,13 @@ def _filter_long_pions_for_charm(): def _filter_long_kaons_for_strange(): return ParticleFilter( make_has_rich_long_kaons(), - F.FILTER(F.require_all(F.PT > 150 * MeV, F.OWNPVIPCHI2 > 6.0, F.PID_K > 2.0)), + F.FILTER( + F.require_all( + F.PT > 150 * MeV, + F.OWNPVIPCHI2 > 6.0, + F.conditionally_skip(F.PID_K > 2.0, label="PID"), + ) + ), ) @@ -126,7 +145,7 @@ def _filter_long_kaons_for_charm(): F.require_all( F.PT > 300 * MeV, F.P > 2.3 * GeV, - F.PID_K > 0.0, + F.conditionally_skip(F.PID_K > 0.0, label="PID"), F.OWNPVIPCHI2 > 4.0, ), ), @@ -463,7 +482,13 @@ def d0(): def prompt_dst(): slow_pi = ParticleFilter( make_has_rich_long_pions(), - F.FILTER(F.require_all(F.PT > 120 * MeV, F.OWNPVIPCHI2 < 6.0, F.PID_K < 16.0)), + F.FILTER( + F.require_all( + F.PT > 120 * MeV, + F.OWNPVIPCHI2 < 6.0, + F.conditionally_skip(F.PID_K < 16.0, label="PID"), + ) + ), ) return ParticleCombiner( [d0(), slow_pi], @@ -544,8 +569,8 @@ def prompt_lc(): F.require_all( F.PT > 500 * MeV, F.OWNPVIPCHI2 > 6.0, - F.PID_P > 10.0, - F.PID_P - F.PID_K > 5.0, + F.conditionally_skip(F.PID_P > 10.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > 5.0, label="PID"), ) ), ) @@ -579,7 +604,7 @@ def prompt_jpsi_to_mumu(): F.PT > 700 * MeV, F.OWNPVIP < 80 * um, F.OWNPVIPCHI2 < 6.0, - F.PID_MU > -3.0, + F.conditionally_skip(F.PID_MU > -3.0, label="PID"), ) ), ) @@ -610,7 +635,7 @@ def prompt_jpsi_to_ee(): F.PT > 800 * MeV, F.OWNPVIP < 80 * um, F.OWNPVIPCHI2 < 6.0, - F.PID_E > 0.0, + F.conditionally_skip(F.PID_E > 0.0, label="PID"), F.GHOSTPROB < 0.5, ) ), diff --git a/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py b/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py index bfc39547e88..a9b8c26d6c5 100644 --- a/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py +++ b/Hlt/RecoConf/python/RecoConf/no_pid_poisoning.py @@ -1,23 +1,33 @@ +############################################################################### +# (c) Copyright 2025 CERN for the benefit of the LHCb Collaboration # +# # +# This software is distributed under the terms of the GNU General Public # +# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". # +# # +# In applying this licence, CERN does not waive the privileges and immunities # +# granted to it by virtue of its status as an Intergovernmental Organization # +# or submit itself to any jurisdiction. # +############################################################################### import Functors as F from RecoConf.no_pid_tool import poison_on_demand def enable_pid_poisoning(): - F.PID_E = poison_on_demand(F.PID_E, label="PID") - F.PID_K = poison_on_demand(F.PID_K, label="PID") + F.PID_E = poison_on_demand(F.PID_E, label="PID") + F.PID_K = poison_on_demand(F.PID_K, label="PID") F.PID_MU = poison_on_demand(F.PID_MU, label="PID") - F.PID_P = poison_on_demand(F.PID_P, label="PID") + F.PID_P = poison_on_demand(F.PID_P, label="PID") F.PID_PI = poison_on_demand(F.PID_PI, label="PID") - F.PROBNN_D = poison_on_demand(F.PROBNN_D, label="PROBNN") - F.PROBNN_E = poison_on_demand(F.PROBNN_E, label="PROBNN") - F.PROBNN_GHOST = poison_on_demand(F.PROBNN_GHOST, label="PROBNN") - F.PROBNN_K = poison_on_demand(F.PROBNN_K, label="PROBNN") - F.PROBNN_MU = poison_on_demand(F.PROBNN_MU, label="PROBNN") - F.PROBNN_P = poison_on_demand(F.PROBNN_P, label="PROBNN") - F.PROBNN_PI = poison_on_demand(F.PROBNN_PI, label="PROBNN") + F.PROBNN_D = poison_on_demand(F.PROBNN_D, label="PROBNN") + F.PROBNN_E = poison_on_demand(F.PROBNN_E, label="PROBNN") + F.PROBNN_GHOST = poison_on_demand(F.PROBNN_GHOST, label="PROBNN") + F.PROBNN_K = poison_on_demand(F.PROBNN_K, label="PROBNN") + F.PROBNN_MU = poison_on_demand(F.PROBNN_MU, label="PROBNN") + F.PROBNN_P = poison_on_demand(F.PROBNN_P, label="PROBNN") + F.PROBNN_PI = poison_on_demand(F.PROBNN_PI, label="PROBNN") F.IS_PHOTON = poison_on_demand(F.IS_PHOTON, label="IS_PHOTON") - F.IS_NOT_H = poison_on_demand(F.IS_NOT_H, label="IS_NOT_H") - F.ISMUON = poison_on_demand(F.ISMUON, label="ISMUON") + F.IS_NOT_H = poison_on_demand(F.IS_NOT_H, label="IS_NOT_H") + F.ISMUON = poison_on_demand(F.ISMUON, label="ISMUON") diff --git a/Hlt/RecoConf/python/RecoConf/rdbuilder_thor.py b/Hlt/RecoConf/python/RecoConf/rdbuilder_thor.py index d476608f44e..90e72132c55 100644 --- a/Hlt/RecoConf/python/RecoConf/rdbuilder_thor.py +++ b/Hlt/RecoConf/python/RecoConf/rdbuilder_thor.py @@ -130,7 +130,7 @@ def make_rd_detached_muons( pt_min=250.0 * MeV, p_min=3000.0 * MeV, mipchi2dvprimary_min=3.0, # TBC - pid=F.require_all(F.ISMUON, F.PID_MU > 0.0), + pid=F.require_all(F.ISMUON, F.conditionally_skip(F.PID_MU > 0.0, label="PID")), make_particles=make_long_muons, ): """ @@ -152,7 +152,7 @@ def make_rd_detached_electrons( pt_min=250.0 * MeV, p_min=3000.0 * MeV, mipchi2dvprimary_min=3.0, # TBC - pid=(F.PID_E > 0.0), + pid=F.conditionally_skip((F.PID_E > 0.0), label="PID"), ): """ Return RD detached electrons with brem recovery. @@ -173,7 +173,7 @@ def make_rd_detached_pions( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, # TBC - pid=(F.PID_K <= 1e-5), + pid=F.conditionally_skip((F.PID_K <= 1e-5), label="PID"), ): """ Return RD detached pions. @@ -194,7 +194,7 @@ def make_rd_detached_kaons( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, # TBC - pid=(F.PID_K > -2.0), + pid=F.conditionally_skip((F.PID_K > -2.0), label="PID"), ): """ Return RD detached kaons. @@ -215,7 +215,7 @@ def make_rd_detached_protons( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, # TBC - pid=(F.PID_P > -2.0), + pid=F.conditionally_skip((F.PID_P > -2.0), label="PID"), ): """ Return RD detached protons. @@ -239,7 +239,7 @@ def make_rd_has_rich_detached_pions( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, # TBC - pid=(F.PID_K <= 0.0), + pid=F.conditionally_skip((F.PID_K <= 0.0), label="PID"), ): """ Return RD detached pions with hasRich. @@ -260,7 +260,7 @@ def make_rd_has_rich_detached_kaons( p_min=2.0 * GeV, pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, # TBC - pid=(F.PID_K > 0.0), + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), ): """ Return RD detached kaons with hasRich. @@ -281,7 +281,10 @@ def make_rd_has_rich_detached_protons( p_min=8.5 * GeV, # kaon RICH threshold below which we have no p-K separation pt_min=250.0 * MeV, mipchi2dvprimary_min=4.0, # TBC - pid=F.require_all(F.PID_P > 0.0, F.PID_P - F.PID_K > -2.0), + pid=F.require_all( + F.conditionally_skip(F.PID_P > 0.0, label="PID"), + F.conditionally_skip(F.PID_P - F.PID_K > -2.0, label="PID"), + ), ): """ Return RD detached protons with hasRich. @@ -306,7 +309,7 @@ def make_rd_prompt_muons( name="rd_prompt_muons_{hash}", pt_min=250.0 * MeV, p_min=3000.0 * MeV, - pid=F.require_all(F.PID_MU > 3.0), + pid=F.require_all(F.conditionally_skip(F.PID_MU > 3.0, label="PID")), ): # F.ISMUON, F.PID_MU > 3. """ Return RD prompt muons. @@ -321,7 +324,7 @@ def make_rd_prompt_electrons( name="rd_prompt_electrons_{hash}", pt_min=250.0 * MeV, p_min=3000.0 * MeV, - pid=(F.PID_E > 6.0), + pid=F.conditionally_skip((F.PID_E > 6.0), label="PID"), ): """ Return RD prompt electrons with brem recovery. @@ -336,7 +339,10 @@ def make_rd_prompt_electrons( @configurable -def make_rd_prompt_pions(name="rd_prompt_pions_{hash}", pid=(F.PID_K < 0.0)): +def make_rd_prompt_pions( + name="rd_prompt_pions_{hash}", + pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), +): """ Return RD prompt pions. """ @@ -354,7 +360,10 @@ def make_rd_prompt_pions_no_rich(name="rd_prompt_pions_{hash}", pid=None): @configurable -def make_rd_prompt_kaons(name="rd_prompt_kaons_{hash}", pid=(F.PID_K > 0.0)): +def make_rd_prompt_kaons( + name="rd_prompt_kaons_{hash}", + pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), +): """ Return RD prompt kaons. """ @@ -365,7 +374,9 @@ def make_rd_prompt_kaons(name="rd_prompt_kaons_{hash}", pid=(F.PID_K > 0.0)): @configurable def make_rd_prompt_protons( - name="rd_prompt_protons_{hash}", p_min=10.0 * GeV, pid=(F.PID_P > 0.0) + name="rd_prompt_protons_{hash}", + p_min=10.0 * GeV, + pid=F.conditionally_skip((F.PID_P > 0.0), label="PID"), ): """ Return RD prompt protons. @@ -517,7 +528,7 @@ def make_rd_photons( code = F.require_all( F.P > e_min, - F.IS_NOT_H > IsNotH_min, + F.conditionally_skip(F.IS_NOT_H > IsNotH_min, label="IS_NOT_H"), ) return ParticleFilter(make_particles(PtCut=et_min), F.FILTER(code), name=name) @@ -544,7 +555,7 @@ def make_rd_merged_pi0s( code = F.PT > pt_min if cl_min is not None: - code &= F.IS_PHOTON < 1.0 - cl_min + code &= F.conditionally_skip(F.IS_PHOTON < 1.0 - cl_min, label="IS_PHOTON") return ParticleFilter(make_particles(), F.FILTER(code), name=name) @@ -950,11 +961,11 @@ def make_rd_detached_kstar0s( # if the RICH can not distinguish between kaons and pions then # the PID will be set to zero, and most often these will correspond # to real pions - pi_pid=F.PID_K < 1e-5, + pi_pid=F.conditionally_skip(F.PID_K < 1e-5, label="PID"), k_p_min=2.0 * GeV, k_pt_min=250.0 * MeV, k_ipchi2_min=9.0, - k_pid=(F.PID_K > 2.0), + k_pid=F.conditionally_skip((F.PID_K > 2.0), label="PID"), kstar0_pt_min=400.0 * MeV, adocachi2cut=30.0, maxdoca=500 * micrometer, @@ -1004,7 +1015,7 @@ def make_rd_detached_phis( k_p_min=2.0 * GeV, k_pt_min=100.0 * MeV, k_ipchi2_min=4.0, - k_pid=(F.PID_K > 0.0), + k_pid=F.conditionally_skip((F.PID_K > 0.0), label="PID"), phi_pt_min=400.0 * MeV, adocachi2cut=30.0, vchi2pdof_max=25.0, @@ -1041,7 +1052,7 @@ def make_rd_detached_rho0( # if the RICH can not distinguish between kaons and pions then # the PID will be set to zero, and most often these will correspond # to real pions - pi_pid=F.PID_K < 1e-5, + pi_pid=F.conditionally_skip(F.PID_K < 1e-5, label="PID"), pt_min=600.0 * MeV, am_min=0.0 * MeV, am_max=2600.0 * MeV, @@ -1084,7 +1095,7 @@ def make_rd_detached_etaprime( pi_p_min=1.0 * GeV, pi_pt_min=150.0 * MeV, pi_ipchi2_min=4.0, - pi_pid=(F.PID_K < 2.0), + pi_pid=F.conditionally_skip((F.PID_K < 2.0), label="PID"), pt_min=500.0 * MeV, am_min=700.0 * MeV, am_max=1300.0 * MeV, @@ -1129,11 +1140,11 @@ def make_rd_detached_k1( pi_p_min=1.0 * GeV, pi_pt_min=150.0 * MeV, pi_ipchi2_min=9.0, - pi_pid=(F.PID_K < 0.0), + pi_pid=F.conditionally_skip((F.PID_K < 0.0), label="PID"), k_p_min=1.0 * GeV, k_pt_min=150.0 * MeV, k_ipchi2_min=9.0, - k_pid=(F.PID_K > -2.0), + k_pid=F.conditionally_skip((F.PID_K > -2.0), label="PID"), pt_min=500.0 * MeV, am_kpi_max=1450 * MeV, am_2pi_max=1450 * MeV, @@ -1197,7 +1208,7 @@ def make_prompt_dielectron_with_brem( particles = electron_maker() code_e = F.require_all( - F.PID_E > PIDe_min, + F.conditionally_skip(F.PID_E > PIDe_min, label="PID"), F.PT > pt_e, ) @@ -1258,7 +1269,9 @@ def make_rd_prompt_dimuons( pt_dimuon_min=0.0 * MeV, pt_muon_min=250.0 * MeV, p_muon_min=3000.0 * MeV, - pid=F.require_all(F.PID_MU > 3.0), # F.ISMUON, F.PID_MU > 3. + pid=F.require_all( + F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), # F.ISMUON, F.PID_MU > 3. pid_best=6, pt_best=0.5 * GeV, p_best=5.0 * GeV, @@ -1282,7 +1295,7 @@ def make_rd_prompt_dimuons( F.PT > pt_dimuon_min, F.MAX(F.PT) > pt_best, F.MAX(F.P) > p_best, - F.MAX(F.PID_MU) > pid_best, + F.conditionally_skip(F.MAX(F.PID_MU) > pid_best, label="PID"), F.MAXSDOCACHI2CUT(adocachi2cut_max), ) vertex_code = F.require_all(F.CHI2DOF < vchi2pdof_max) @@ -1304,8 +1317,10 @@ def make_rd_prompt_mue( p_muon_min=3000.0 * MeV, pt_electron_min=300.0 * MeV, p_electron_min=3000.0 * MeV, - pid_muon=F.require_all(F.PID_MU > 3.0), # F.ISMUON, F.PID_MU > 3. - pid_electron=(F.PID_E > 5.0), + pid_muon=F.require_all( + F.conditionally_skip(F.PID_MU > 3.0, label="PID") + ), # F.ISMUON, F.PID_MU > 3. + pid_electron=F.conditionally_skip((F.PID_E > 5.0), label="PID"), pt_best=0.5 * GeV, p_best=5.0 * GeV, adocachi2cut_max=30.0, @@ -1373,7 +1388,9 @@ def make_rd_detached_dimuon( pt_min=pt_muon_min, p_min=p_muon_min, mipchi2dvprimary_min=ipchi2_muon_min, - pid=F.require_all(F.ISMUON, F.PID_MU > pidmu_muon_min), + pid=F.require_all( + F.ISMUON, F.conditionally_skip(F.PID_MU > pidmu_muon_min, label="PID") + ), make_particles=make_particles_muon, ) @@ -1449,7 +1466,9 @@ def make_rd_detached_dielectron_invpid( fake_electrons=fake_electrons, ) - code = F.CHILD(1, F.PID_E < pid_e_max) | F.CHILD(2, F.PID_E < pid_e_max) + code = F.CHILD(1, F.conditionally_skip(F.PID_E < pid_e_max, label="PID")) | F.CHILD( + 2, F.conditionally_skip(F.PID_E < pid_e_max, label="PID") + ) return ParticleFilter(dielectrons, F.FILTER(code), name=name) @@ -1658,7 +1677,7 @@ def make_rd_tauons_hadronic_decay( pi_pt_min=150.0 * MeV, pi_p_min=1000.0 * MeV, pi_ipchi2_min=4.0, - pi_pid=(F.PID_K < 8.0), + pi_pid=F.conditionally_skip((F.PID_K < 8.0), label="PID"), best_pi_pt_min=300.0 * MeV, best_pi_ipchi2_min=5.0, am_min=400.0 * MeV, @@ -1810,13 +1829,13 @@ def make_rd_detached_K1( p_min=K_p_min, pt_min=K_pt_min, mipchi2dvprimary_min=K_ipchi2_min, - pid=(F.PID_K > K_PIDK_min), + pid=F.conditionally_skip((F.PID_K > K_PIDK_min), label="PID"), ) pions = make_rd_detached_pions( p_min=pi_p_min, pt_min=pi_pt_min, mipchi2dvprimary_min=pi_ipchi2_min, - pid=(F.PID_K <= pi_PIDK_max), + pid=F.conditionally_skip((F.PID_K <= pi_PIDK_max), label="PID"), ) two_body_combination_code = F.require_all( @@ -1863,7 +1882,7 @@ def make_rd_detached_K2( K_p_min=2_000.0 * MeV, K_pt_min=400.0 * MeV, K_ipchi2_min=9.0, - K_PIDK=(F.PID_K > 5.0), + K_PIDK=F.conditionally_skip((F.PID_K > 5.0), label="PID"), K_2_min_ownpvfdchi2=0.0, K_2_pt_min=0.0 * MeV, vchi2pdof_max=12.0, diff --git a/Hlt/RecoConf/python/RecoConf/standard_particles.py b/Hlt/RecoConf/python/RecoConf/standard_particles.py index 60465d53d22..af2e80242f4 100644 --- a/Hlt/RecoConf/python/RecoConf/standard_particles.py +++ b/Hlt/RecoConf/python/RecoConf/standard_particles.py @@ -839,31 +839,39 @@ def filter_leptons_loose( code = code & (F.GHOSTPROB > trghostprob) if lepton == "muon": if probnn_mu is not None: - code = code & (F.PROBNN_MU < probnn_mu) + code = code & F.conditionally_skip( + (F.PROBNN_MU < probnn_mu), label="PROBNN" + ) if pid_mu is not None: - code = code & (F.PID_MU < pid_mu) + code = code & F.conditionally_skip((F.PID_MU < pid_mu), label="PID") if ismuon: - code = code & (~F.ISMUON) + code = code & F.conditionally_skip((~F.ISMUON), label="ISMUON") elif lepton == "electron": if pid_e is not None: - code = code & (F.PID_E < pid_e) + code = code & F.conditionally_skip((F.PID_E < pid_e), label="PID") if probnn_e is not None: - code = code & (F.PROBNN_E < probnn_e) + code = code & F.conditionally_skip( + (F.PROBNN_E < probnn_e), label="PROBNN" + ) else: if trghostprob is not None: code = code & (F.GHOSTPROB < trghostprob) if lepton == "muon": if probnn_mu is not None: - code = code & (F.PROBNN_MU > probnn_mu) + code = code & F.conditionally_skip( + (F.PROBNN_MU > probnn_mu), label="PROBNN" + ) if pid_mu is not None: - code = code & (F.PID_MU > pid_mu) + code = code & F.conditionally_skip((F.PID_MU > pid_mu), label="PID") if ismuon: code = code & (F.ISMUON) elif lepton == "electron": if pid_e is not None: - code = code & (F.PID_E > pid_e) + code = code & F.conditionally_skip((F.PID_E > pid_e), label="PID") if probnn_e is not None: - code = code & (F.PROBNN_E > probnn_e) + code = code & F.conditionally_skip( + (F.PROBNN_E > probnn_e), label="PROBNN" + ) return ParticleFilter(particles, F.FILTER(code)) @@ -976,9 +984,9 @@ def make_prompt_dielectron_with_brem( F.PT > pt_e, F.P > p_e, F.MINIPCHI2(pvs) < maxipchi2, F.GHOSTPROB < trghostprob ) if PIDe_min is not None: - code_e = code_e & (F.PID_E > PIDe_min) + code_e = code_e & F.conditionally_skip((F.PID_E > PIDe_min), label="PID") if probnn_e is not None: - code_e = code_e & (F.PROBNN_E > probnn_e) + code_e = code_e & F.conditionally_skip((F.PROBNN_E > probnn_e), label="PROBNN") prompt_e = ParticleFilter(particles, F.FILTER(code_e)) prompt_dielectron_with_brem = _make_dielectron_with_brem( @@ -1064,14 +1072,18 @@ def make_detached_dielectron_with_brem( if PIDe_min is not None: code_dielectron = ( code_dielectron - & (F.CHILD(1, F.PID_E) < PIDe_min) - & (F.CHILD(2, F.PID_E) > PIDe_min) + & F.conditionally_skip((F.CHILD(1, F.PID_E) < PIDe_min), label="PID") + & F.conditionally_skip((F.CHILD(2, F.PID_E) > PIDe_min), label="PID") ) if probnn_e is not None: code_dielectron = ( code_dielectron - & (F.CHILD(1, F.PROBNN_E) < probnn_e) - & (F.CHILD(2, F.PROBNN_E) > probnn_e) + & F.conditionally_skip( + (F.CHILD(1, F.PROBNN_E) < probnn_e), label="PROBNN" + ) + & F.conditionally_skip( + (F.CHILD(2, F.PROBNN_E) > probnn_e), label="PROBNN" + ) ) return ParticleFilter(detached_dielectron_with_brem, F.FILTER(code_dielectron)) @@ -1368,7 +1380,11 @@ def make_phi2kk( kaons = ParticleFilter( make_has_rich_long_kaons(), F.FILTER( - F.require_all(F.P > kaon_p_min, F.PT > kaon_pt_min, F.PID_K > kaon_pidk_min) + F.require_all( + F.P > kaon_p_min, + F.PT > kaon_pt_min, + F.conditionally_skip(F.PID_K > kaon_pidk_min, label="PID"), + ) ), ) descriptors = "phi(1020) -> K+ K-" @@ -1649,7 +1665,7 @@ def make_ttrack_protons_for_V0( in_range(minipchi2_min, F.MINIPCHI2(pvs), minipchi2_max), ) if pid_p_min is not None: - proton_cuts &= F.PID_P > pid_p_min + proton_cuts &= F.conditionally_skip(F.PID_P > pid_p_min, label="PID") return ParticleFilter(protons, F.FILTER(proton_cuts)) diff --git a/ReleaseNotes/legacy.html b/ReleaseNotes/legacy.html index c13c2d5c1d3..2d687f60b97 100755 --- a/ReleaseNotes/legacy.html +++ b/ReleaseNotes/legacy.html @@ -1,4 +1,14 @@ 
+
 Package             : MooreSys
 Package Coordinator : Rosen Matev, Roel Aaij
 Purpose             : LHCb HLT application
-- 
GitLab


From f52068decdcb3c2a299b12313693f22f0fc8adee Mon Sep 17 00:00:00 2001
From: Jan wagner 
Date: Mon, 8 Dec 2025 06:00:14 +0100
Subject: [PATCH 11/16] Retrigger pipeline

-- 
GitLab


From 9ec2aaed0dc11cf27cabac8d91268f5f4b733cb0 Mon Sep 17 00:00:00 2001
From: Jan wagner 
Date: Mon, 8 Dec 2025 06:19:28 +0100
Subject: [PATCH 12/16] Add libcst to pre-commit install

---
 .pre-commit-config.yaml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 0ad32462bf4..b64eb55e728 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -34,9 +34,9 @@ repos:
     -   id: wrap-pid-conditions
         name: Wrap PID cuts with conditionally_skip + ensure import
         entry: python3 scripts/wrap_pid_conditions.py
-        language: system
-        types: [python]
+        language: python
         pass_filenames: true
-        additional_dependencies: []
+        additional_dependencies:
+            - libcst==1.8.6
         # To fail CI without auto-fixing, switch to:
         # entry: python3 scripts/wrap_pid_conditions.py --check
-- 
GitLab


From d5c28d5b8ddaa207ab3b0458910782b6399c1e7b Mon Sep 17 00:00:00 2001
From: Jan wagner 
Date: Mon, 8 Dec 2025 11:59:42 +0100
Subject: [PATCH 13/16] Rename underscore _CALO_NEUTRAL_ID functor

---
 Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/pi0_line.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/pi0_line.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/pi0_line.py
index adf66374347..4a43c3173fc 100644
--- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/pi0_line.py
+++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/monitoring/pi0_line.py
@@ -45,8 +45,8 @@ def pi0_monitoring(
         [photons, photons], "pi0 -> gamma gamma", pt_min=pi0_et, m_max=max_mass
     )
 
-    PHOTONAREA_1 = F.CHILD(1, F.CALOCELLID_AREA @ F._CALO_NEUTRAL_ID)
-    PHOTONAREA_2 = F.CHILD(2, F.CALOCELLID_AREA @ F._CALO_NEUTRAL_ID)
+    PHOTONAREA_1 = F.CHILD(1, F.CALOCELLID_AREA @ F.CALO_NEUTRAL_ID_BASE)
+    PHOTONAREA_2 = F.CHILD(2, F.CALOCELLID_AREA @ F.CALO_NEUTRAL_ID_BASE)
 
     checkPi0_M = monitor(
         data=pi0s,
-- 
GitLab


From d82fb0a3c6bd6376edfa43d5ddf4bc21b8fa5e2e Mon Sep 17 00:00:00 2001
From: Jan wagner 
Date: Wed, 10 Dec 2025 16:14:49 +0100
Subject: [PATCH 14/16] Adapt production.py for new runtime stable poisoning

---
 Hlt/Moore/python/Moore/production.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Hlt/Moore/python/Moore/production.py b/Hlt/Moore/python/Moore/production.py
index c5effbdd6c9..652956ac5a7 100644
--- a/Hlt/Moore/python/Moore/production.py
+++ b/Hlt/Moore/python/Moore/production.py
@@ -285,7 +285,8 @@ def _hlt2(
 
     # Bind labels, apply poisoning, then run Moore
     with functor_label_switches.bind(labels=disabled_labels):
-        enable_pid_poisoning()
+        if disabled_labels:
+            enable_pid_poisoning()
         with reconstruction.bind(from_file=False), _apply_track_binds():
             config = run_moore(options, _my_line_maker, public_tools)
 
@@ -586,7 +587,8 @@ def _spruce(
 
             # Bind labels & poison before configuring
             with functor_label_switches.bind(labels=disabled_labels):
-                enable_pid_poisoning()
+                if disabled_labels:
+                    enable_pid_poisoning()
                 config.update(
                     configure(options, moore_control_node, public_tools=public_tools)
                 )
-- 
GitLab


From b10243050547d9b38354e913eb363e8007693fb2 Mon Sep 17 00:00:00 2001
From: Jan wagner 
Date: Wed, 10 Dec 2025 17:13:23 +0100
Subject: [PATCH 15/16] Add detailed checking of ISMUON

---
 scripts/wrap_pid_conditions.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/scripts/wrap_pid_conditions.py b/scripts/wrap_pid_conditions.py
index b3c34125dbb..610b4a2c2eb 100755
--- a/scripts/wrap_pid_conditions.py
+++ b/scripts/wrap_pid_conditions.py
@@ -366,6 +366,28 @@ class WrapPidCuts(cst.CSTTransformer):
                 new_args.append(a.with_changes(value=v))
             return updated_node.with_changes(args=new_args)
 
+        # 3) NEW: require_all / require_any
+        if fn in {"require_all", "require_any"}:
+            new_args = []
+            changed = False
+            for a in updated_node.args:
+                v = a.value
+                if v is None:
+                    new_args.append(a)
+                    continue
+                if is_conditionally_skip_call(v):
+                    new_args.append(a)
+                    continue
+                if isinstance(v, cst.Comparison):
+                    new_args.append(a)
+                    continue
+                if contains_pid_or_derived(v, self.derived):
+                    v = self._wrap(v)
+                    changed = True
+                new_args.append(a.with_changes(value=v))
+            if changed:
+                return updated_node.with_changes(args=new_args)
+
         return updated_node
 
     def leave_Comparison(
-- 
GitLab


From c78b7c0a0ea908745f149fb3940dd5f1b521fecb Mon Sep 17 00:00:00 2001
From: Jan Wagner 
Date: Wed, 10 Dec 2025 20:26:55 +0100
Subject: [PATCH 16/16] Fix manually some false positive conditionally_skip

---
 .../python/Hlt2Conf/lines/rd/builders/strange.py         | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py
index e462dce32bf..2650cc3fa6e 100644
--- a/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py
+++ b/Hlt/Hlt2Conf/python/Hlt2Conf/lines/rd/builders/strange.py
@@ -1741,16 +1741,15 @@ def particle_maker(particle_name, basic_type="charged"):
                 **REQUIREMENTS_FOR_PARTICLE_ID[particle_name][tags],
             }
 
-            if F.conditionally_skip(tags.selection == "standard"):
+            if tags.selection == "standard":
                 tags_mod = tags.modified(selection="loose")
-            elif F.conditionally_skip(tags.selection == "tight"):
+            elif tags.selection == "tight":
                 tags_mod = tags.modified(selection="standard")
             else:
                 tags_mod = None
 
-            has_lower_requirements = tags_mod is not None and F.conditionally_skip(
-                rec_requirements[tags] is not rec_requirements[tags_mod]
-            )
+            has_lower_requirements = tags_mod is not None and rec_requirements[tags] is not rec_requirements[tags_mod]
+            
 
             if has_lower_requirements:
                 particles = builder(tags_mod, *args, **kwargs)
-- 
GitLab