add an option to drop filter rules for a given dataset

Author: scarlehoff

doc/sphinx/source/vp/filters.rst

@@ -307,6 +307,33 @@ append a list of filter rules to the rules obtained by the mechanisms described
 The value of ``added_filter_rules`` should be a list of rules with the same format as ``filter_rules``.
 
 
+.. _drop_filter_rules::
+
+Dropping filter rules for selected datasets
+-------------------------------------------
+
+Sometimes it might be necessary to drop the filter rules for a dataset while keeping all other rules intact.
+This is possible with the ``drop_filter_rules`` key, which will drop all dataset-scoped rules applying to a given dataset.
+Since ``drop_filter_rules`` is applied before ``added_filter_rules`` it can be utilized to reset the rules for a given dataset
+while keeping all other internal rules.
+
+.. code:: yaml
+
+    use_cuts: "internal"
+    pdf: "NNPDF40_nnlo_as_01180"
+
+    dataset_inputs:
+      - { dataset: ATLAS_Z0J_8TEV_PT-Y }
+      - { dataset: ATLAS_Z0J_8TEV_PT-M }
+
+    theoryid: 40_000_000
+
+    drop_internal_rules:
+      - ATLAS_Z0J_8TEV_PT-Y
+
+    actions_:
+      - groups_chi2_table
+
 
 Examples
 --------
@@ -345,13 +372,13 @@ less than NNLO (i.e LO or NLO). I check what the process type of
 
 .. code:: ipython
 
-   In [1]: from validphys.loader import Loader                                                                                                                                   
+   In [1]: from validphys.loader import Loader
 
-   In [2]: l = Loader()                                                                                                                                                          
+   In [2]: l = Loader()
 
-   In [3]: cd = l.check_commondata("CMSDY2D12")                                                                                                                                  
+   In [3]: cd = l.check_commondata("CMSDY2D12")
 
-   In [4]: cd.process_type                                                                                                                                                       
+   In [4]: cd.process_type
    Out[4]: 'EWK_RAP'
 
 Then cross check this against ``NNPDF.CommonData.kinLabels`` to see that

validphys2/src/validphys/config.py

@@ -1372,7 +1372,13 @@ def parse_added_filter_rules(self, rules: (list, type(None)) = None):
         """
         return tuple(AddedFilterRule(**rule) for rule in rules) if rules else None
 
-    @functools.lru_cache
+    def parse_drop_internal_rules(self, drop_internal_rules: list | None = None):
+        """Turns drop_internal_rules into a tuple for internal caching."""
+        if drop_internal_rules is None:
+            return tuple()
+        return tuple(drop_internal_rules)
+
+    @functools.cache
     def produce_rules(
         self,
         theoryid,
@@ -1382,8 +1388,20 @@ def produce_rules(
         filter_rules=None,
         default_filter_rules_recorded_spec_=None,
         added_filter_rules: (tuple, type(None)) = None,
+        drop_internal_rules: tuple = tuple(),
     ):
-        """Produce filter rules based on the user defined input and defaults."""
+        """Produce filter rules based on the user defined input and defaults.
+
+        It is possible to overwrite or extend the internal rules from the runcard
+        using the following variables:
+
+        ``filter_rules``: tuple(rules)
+            Drop all internal rules and take these instead
+        ``added_filter_rules``: tuple(rules)
+            Extended internal rules with these
+        ``drop_internal_rules``: tuple(dataset names)
+            Drop internal dataset-specific rules, it is applied before ``added_filter_rules``
+        """
 
         theory_parameters = theoryid.get_description()
 
@@ -1397,15 +1415,20 @@ def produce_rules(
                 filter_rules = default_filter_rules_input()
 
         try:
-            rule_list = [
-                Rule(
-                    initial_data=rule,
-                    defaults=defaults,
-                    theory_parameters=theory_parameters,
-                    loader=self.loader,
+            rule_list = []
+            for rule in filter_rules:
+                # Don't load rules that are to be dropped
+                if rule.dataset in drop_internal_rules:
+                    continue
+
+                rule_list.append(
+                    Rule(
+                        initial_data=rule,
+                        defaults=defaults,
+                        theory_parameters=theory_parameters,
+                        loader=self.loader,
+                    )
                 )
-                for rule in filter_rules
-            ]
         except RuleProcessingError as e:
             raise ConfigError(f"Error Processing filter rules: {e}") from e