add helper functions for co-dependent parameter detection

5 files changed, 230 insertions, 72 deletions

diff --git a/bin/analyze-archive.py b/bin/analyze-archive.py
index 47fabd4..685ce92 100644..100755
--- a/bin/analyze-archive.py
+++ b/bin/analyze-archive.py
@@ -311,10 +311,10 @@ if __name__ == '__main__':
                     '',
                     param,
                     model.stats.param_dependence_ratio(state, 'power', param)))
-                if model.depends_on_param(state, 'power', param) and len(model.stats.stats[state]['power']['param_data'][param]['codependent_parameters']):
-                    print('{:24s}  co-dependencies: {:s}'.format('', ', '.join(model.stats.stats[state]['power']['param_data'][param]['codependent_parameters'])))
-                    for combi, depends in model.stats.stats[state]['power']['param_data'][param]['depends_for_codependent_value'].items():
-                        print('{} -> {}'.format(combi, depends))
+                if model.stats.has_codependent_parameters(state, 'power', param):
+                    print('{:24s}  co-dependencies: {:s}'.format('', ', '.join(model.stats.codependent_parameters(state, 'power', param))))
+                    for param_dict in model.stats.codependent_parameter_value_dicts(state, 'power', param):
+                        print('{:24s}  parameter-aware for {}'.format('', param_dict))
 
         for trans in model.transitions():
             # Mean power is not a typical transition attribute, but may be present for debugging or analysis purposes
@@ -377,6 +377,8 @@ if __name__ == '__main__':
                             ))
 
     if 'param' in show_models or 'all' in show_models:
+        if not model.stats.can_be_fitted():
+            print('[!] measurements have insufficient distinct numeric parameters for fitting. A parameter-aware model is not available.')
         for state in model.states():
             for attribute in model.attributes(state):
                 if param_info(state, attribute):
diff --git a/bin/analyze-timing.py b/bin/analyze-timing.py
index 659a3d7..6c84a67 100755
--- a/bin/analyze-timing.py
+++ b/bin/analyze-timing.py
@@ -21,6 +21,9 @@ Options:
     parameters. Also plots the corresponding measurements.
     If gplearn function is set, it is plotted using dashed lines.
 
+--param-info
+    Show parameter names and values
+
 --show-models=<static|paramdetection|param|all|tex>
     static: show static model values as well as parameter detection heuristic
     paramdetection: show stddev of static/lut/fitted model
@@ -77,7 +80,8 @@ import re
 import sys
 from dfatool import AnalyticModel, TimingData, pta_trace_to_aggregate
 from dfatool import soft_cast_int, is_numeric, gplearn_to_function
-from dfatool import CrossValidator, filter_aggregate_by_param
+from dfatool import CrossValidator
+from utils import filter_aggregate_by_param
 from parameters import prune_dependent_parameters
 import utils
 
@@ -151,7 +155,7 @@ if __name__ == '__main__':
             'ignored-trace-indexes= discard-outliers= function-override= '
             'filter-param= '
             'cross-validate= '
-            'corrcoef '
+            'corrcoef param-info '
             'with-safe-functions hwmodel= export-energymodel='
         )
         raw_opts, args = getopt.getopt(sys.argv[1:], "", optspec.split(' '))
@@ -216,6 +220,12 @@ if __name__ == '__main__':
     if xv_method:
         xv = CrossValidator(AnalyticModel, by_name, parameters, arg_count)
 
+    if 'param-info' in opts:
+        for state in model.names:
+            print('{}:'.format(state))
+            for param in model.parameters:
+                print('    {} = {}'.format(param, model.stats.distinct_values[state][param]))
+
     if 'plot-unparam' in opts:
         for kv in opts['plot-unparam'].split(';'):
             state_or_trans, attribute, ylabel = kv.split(':')
@@ -228,6 +238,15 @@ if __name__ == '__main__':
     if 'static' in show_models or 'all' in show_models:
         for trans in model.names:
             print('{:10s}: {:.0f} µs'.format(trans, static_model(trans, 'duration')))
+            for param in model.parameters:
+                print('{:10s}  dependence on {:15s}: {:.2f}'.format(
+                    '',
+                    param,
+                    model.stats.param_dependence_ratio(trans, 'duration', param)))
+                if model.stats.has_codependent_parameters(trans, 'duration', param):
+                    print('{:24s}  co-dependencies: {:s}'.format('', ', '.join(model.stats.codependent_parameters(trans, 'duration', param))))
+                    for param_dict in model.stats.codependent_parameter_value_dicts(trans, 'duration', param):
+                        print('{:24s}  parameter-aware for {}'.format('', param_dict))
 
     if xv_method == 'montecarlo':
         static_quality = xv.montecarlo(lambda m: m.get_static(), xv_count)
diff --git a/lib/dfatool.py b/lib/dfatool.py
index 478f800..a3d5c0f 100644
--- a/lib/dfatool.py
+++ b/lib/dfatool.py
@@ -18,7 +18,7 @@ from functions import analytic
 from functions import AnalyticFunction
 from parameters import ParamStats
 from utils import vprint, is_numeric, soft_cast_int, param_slice_eq, remove_index_from_tuple
-from utils import by_name_to_by_param
+from utils import by_name_to_by_param, match_parameter_values
 
 arg_support_enabled = True
 
@@ -505,12 +505,10 @@ class RawData:
         self.cache_file = '{}/{}.json'.format(self.cache_dir, cache_key)
 
     def load_cache(self):
-        print('checking {}...'.format(self.cache_file))
         if os.path.exists(self.cache_file):
             with open(self.cache_file, 'r') as f:
                 self.traces = json.load(f)
                 self.preprocessed = True
-                print('loaded cache')
 
     def save_cache(self):
         try:
@@ -902,15 +900,15 @@ class ParallelParamFit:
         self.fit_queue = []
         self.by_param = by_param
 
-    def enqueue(self, state_or_tran, attribute, param_index, param_name, safe_functions_enabled = False):
+    def enqueue(self, state_or_tran, attribute, param_index, param_name, safe_functions_enabled = False, param_filter = None):
         """
         Add state_or_tran/attribute/param_name to fit queue.
 
         This causes fit() to compute the best-fitting function for this model part.
         """
         self.fit_queue.append({
-            'key' : [state_or_tran, attribute, param_name],
-            'args' : [self.by_param, state_or_tran, attribute, param_index, safe_functions_enabled]
+            'key' : [state_or_tran, attribute, param_name, param_filter],
+            'args' : [self.by_param, state_or_tran, attribute, param_index, safe_functions_enabled, param_filter]
         })
 
     def fit(self):
@@ -935,16 +933,17 @@ def _try_fits_parallel(arg):
         'result' : _try_fits(*arg['args'])
     }
 
-
-def _try_fits(by_param, state_or_tran, model_attribute, param_index, safe_functions_enabled = False):
+def _try_fits(by_param, state_or_tran, model_attribute, param_index, safe_functions_enabled = False, param_filter: dict = None):
     """
     Determine goodness-of-fit for prediction of `by_param[(state_or_tran, *)][model_attribute]` dependence on `param_index` using various functions.
 
     This is done by varying `param_index` while keeping all other parameters constant and doing one least squares optimization for each function and for each combination of the remaining parameters.
     The value of the parameter corresponding to `param_index` (e.g. txpower or packet length) is the sole input to the model function.
+    Only numeric parameter values (as determined by `utils.is_numeric`) are used for fitting, non-numeric values such as None or enum strings are ignored.
+    Fitting is only performed if at least three distinct parameter values exist in `by_param[(state_or_tran, *)]`.
 
-    :return:  a dictionary with the following elements:
-        best -- name of the best-fitting function (see `analytic.functions`)
+    :returns:  a dictionary with the following elements:
+        best -- name of the best-fitting function (see `analytic.functions`). `None` in case of insufficient data.
         best_rmsd -- mean Root Mean Square Deviation of best-fitting function over all combinations of the remaining parameters
         mean_rmsd -- mean Root Mean Square Deviation of a reference model using the mean of its respective input data as model value
         median_rmsd -- mean Root Mean Square Deviation of a reference model using the median of its respective input data as model value
@@ -961,6 +960,7 @@ def _try_fits(by_param, state_or_tran, model_attribute, param_index, safe_functi
     
     :param param_index: index of the parameter used as model input
     :param safe_functions_enabled: Include "safe" variants of functions with limited argument range.
+    :param param_filter: Only use measurements whose parameters match param_filter for fitting.
     """
 
     functions = analytic.functions(safe_functions_enabled = safe_functions_enabled)
@@ -987,7 +987,7 @@ def _try_fits(by_param, state_or_tran, model_attribute, param_index, safe_functi
     seen_parameter_combinations = set()
 
     # for each parameter combination:
-    for param_key in filter(lambda x: x[0] == state_or_tran and remove_index_from_tuple(x[1], param_index) not in seen_parameter_combinations, by_param.keys()):
+    for param_key in filter(lambda x: x[0] == state_or_tran and remove_index_from_tuple(x[1], param_index) not in seen_parameter_combinations and len(by_param[x]['param']) and match_parameter_values(by_param[x]['param'][0], param_filter), by_param.keys()):
         X = []
         Y = []
         num_valid = 0
@@ -1087,7 +1087,7 @@ def _num_args_from_by_name(by_name):
             num_args[key] = len(value['args'][0])
     return num_args
 
-def get_fit_result(results, name, attribute, verbose = False):
+def get_fit_result(results, name, attribute, verbose = False, param_filter: dict = None):
     """
     Parse and sanitize fit results for state/transition/... 'name' and model attribute 'attribute'.
 
@@ -1097,10 +1097,12 @@ def get_fit_result(results, name, attribute, verbose = False):
     :param name: state/transition/... name, e.g. 'TX'
     :param attribute: model attribute, e.g. 'duration'
     :param verbose: print debug message to stdout when deliberately not using a determined fit function
+    :param param_filter: 
+    :returns: dict with fit result (see `_try_fits`) for each successfully fitted parameter. E.g. {'param 1': {'best' : 'function name', ...} }
     """
     fit_result = dict()
     for result in results:
-        if result['key'][0] == name and result['key'][1] == attribute and result['result']['best'] != None:
+        if result['key'][0] == name and result['key'][1] == attribute and result['key'][3] == param_filter and result['result']['best'] != None: # dürfte an ['best'] != None liegen-> Fit für gefilterten Kram schlägt fehl?
             this_result = result['result']
             if this_result['best_rmsd'] >= min(this_result['mean_rmsd'], this_result['median_rmsd']):
                 vprint(verbose, '[I] Not modeling {} {} as function of {}: best ({:.0f}) is worse than ref ({:.0f}, {:.0f})'.format(
@@ -1583,7 +1585,7 @@ class PTAModel:
         """
         Get static model function: name, attribute -> model value.
 
-        Uses the median of by_name for modeling.
+        Uses the median of by_name for modeling, unless `use_mean` is set.
         """
         getter_function = np.median
 
@@ -1633,7 +1635,7 @@ class PTAModel:
 
     def get_fitted(self, safe_functions_enabled = False):
         """
-        Get paramete-aware model function and model information function.
+        Get parameter-aware model function and model information function.
 
         Returns two functions:
         model_function(name, attribute, param=parameter values) -> model value.
@@ -1651,6 +1653,8 @@ class PTAModel:
                 for parameter_index, parameter_name in enumerate(self._parameter_names):
                     if self.depends_on_param(state_or_tran, model_attribute, parameter_name):
                         paramfit.enqueue(state_or_tran, model_attribute, parameter_index, parameter_name, safe_functions_enabled)
+                        for codependent_param_dict in self.stats.codependent_parameter_value_dicts(state_or_tran, model_attribute, parameter_name):
+                            paramfit.enqueue(state_or_tran, model_attribute, parameter_index, parameter_name, safe_functions_enabled, codependent_param_dict)
                 if arg_support_enabled and self.by_name[state_or_tran]['isa'] == 'transition':
                     for arg_index in range(self._num_args[state_or_tran]):
                         if self.depends_on_arg(state_or_tran, model_attribute, arg_index):
@@ -1664,6 +1668,12 @@ class PTAModel:
             for model_attribute in self.by_name[state_or_tran]['attributes']:
                 fit_results = get_fit_result(paramfit.results, state_or_tran, model_attribute, self.verbose)
 
+                for parameter_name in self._parameter_names:
+                    if self.depends_on_param(state_or_tran, model_attribute, parameter_name):
+                        for codependent_param_dict in self.stats.codependent_parameter_value_dicts(state_or_tran, model_attribute, parameter_name):
+                            pass
+                            # FIXME get_fit_result hat ja gar keinen Parameter als Argument...
+
                 if (state_or_tran, model_attribute) in self.function_override:
                     function_str = self.function_override[(state_or_tran, model_attribute)]
                     x = AnalyticFunction(function_str, self._parameter_names, num_args)
diff --git a/lib/parameters.py b/lib/parameters.py
index 1518076..bc26643 100644
--- a/lib/parameters.py
+++ b/lib/parameters.py
@@ -19,8 +19,6 @@ def distinct_param_values(by_name, state_or_tran):
     write() or similar has not been called yet. Other parameters should always
     be initialized when leaving UNINITIALIZED.
     """
-    # TODO a set() is an _unordered_ collection, so this must be converted to
-    # an OrderedDict or a list with a duplicate-pruning step
     distinct_values = [OrderedDict() for i in range(len(by_name[state_or_tran]['param'][0]))]
     for param_tuple in by_name[state_or_tran]['param']:
         for i in range(len(param_tuple)):
@@ -32,31 +30,37 @@ def distinct_param_values(by_name, state_or_tran):
 
 def _std_by_param(by_param, all_param_values, state_or_tran, attribute, param_index, verbose = False):
     u"""
-    Calculate standard deviations for a static model where all parameters but param_index are constant.
+    Calculate standard deviations for a static model where all parameters but `param_index` are constant.
 
     :param by_param: measurements sorted by key/transition name and parameter values
+    :param all_param_values: distinct values of each parameter in `state_or_tran`.
+        E.g. for two parameters, the first being None, FOO, or BAR, and the second being 1, 2, 3, or 4, the argument is
+        `[[None, 'FOO', 'BAR'], [1, 2, 3, 4]]`.
     :param state_or_tran: state or transition name (-> by_param[(state_or_tran, *)])
     :param attribute: model attribute, e.g. 'power' or 'duration'
            (-> by_param[(state_or_tran, *)][attribute])
     :param param_index: index of variable parameter
-    :returns: (stddev matrix, mean stddev)
-
-    Returns the mean standard deviation of all measurements of 'attribute'
-    (e.g. power consumption or timeout) for state/transition 'state_or_tran' where
-    parameter 'param_index' is dynamic and all other parameters are fixed.
-    I.e., if parameters are a, b, c ∈ {1,2,3} and 'index' corresponds to b, then
-    this function returns the mean of the standard deviations of (a=1, b=*, c=1),
-    (a=1, b=*, c=2), and so on.
-    Also returns an (n-1)-dimensional array (where n is the number of parameters)
-    giving the standard deviation of each individual partition. E.g. for
-    param_index == 2 and 4 parameters, array[a][b][d] is the
-    stddev of measurements with param0 == a, param1 == b, param2 variable,
-    and param3 == d.
+    :returns: (stddev matrix, mean stddev, LUT matrix)
+        *stddev matrix* is an ((number of parameters)-1)-dimensional matrix giving the standard deviation of each individual parameter variation partition.
+        E.g. for param_index == 2 and 4 parameters, stddev matrix[a][b][d] is the stddev of
+        measurements with param0 == all_param_values[0][a],
+        param1 == all_param_values[1][b], param2 variable, and
+        param3 == all_param_values[3][d].
+        *mean stddev* is the mean standard deviation of all measurements of `attribute`
+        for `state_or_tran` where parameter `param_index` is dynamic and all other parameters are fixed.
+        E.g., if parameters are a, b, c ∈ {1,2,3} and 'index' corresponds to b, then
+        this function returns the mean of the standard deviations of (a=1, b=*, c=1),
+        (a=1, b=*, c=2), and so on.
+        *LUT matrix* is an ((number of parameters)-1)-dimensional matrix giving the mean standard deviation of individual partitions with entirely constant parameters.
+        E.g. for param_index == 2 and 4 parameters, LUT matrix[a][b][d] is the mean of
+        stddev(param0 -> a, param1 -> b, param2 -> first distinct value, param3 -> d),
+        stddev(param0 -> a, param1 -> b, param2 -> second distinct value, param3 -> d),
+        and so on.
     """
     param_values = list(remove_index_from_tuple(all_param_values, param_index))
     info_shape = tuple(map(len, param_values))
 
-    # We will calculate the mean over the entire matrix later on. We cannot
+    # We will calculate the mean over the entire matrix later on. As we cannot
     # guarantee that each entry will be filled in this loop (e.g. transitions
     # whose arguments are combined using 'zip' rather than 'cartesian' always
     # have missing parameter combinations), we pre-fill it with NaN and use
@@ -87,13 +91,25 @@ def _std_by_param(by_param, all_param_values, state_or_tran, attribute, param_in
         #    vprint(verbose, '[W] parameter value partition for {} is empty'.format(param_value))
 
     if np.all(np.isnan(stddev_matrix)):
-        vprint(verbose, '[W] {}/{} parameter #{} has no data partitions -- how did this even happen?'.format(state_or_tran, attribute, param_index))
-        vprint(verbose, 'stddev_matrix = {}'.format(stddev_matrix))
+        print('[W] {}/{} parameter #{} has no data partitions -- how did this even happen?'.format(state_or_tran, attribute, param_index))
+        print('stddev_matrix = {}'.format(stddev_matrix))
         return stddev_matrix, 0.
 
     return stddev_matrix, np.nanmean(stddev_matrix), lut_matrix #np.mean([np.std(partition) for partition in partitions])
 
 def _corr_by_param(by_name, state_or_trans, attribute, param_index):
+    """
+    Return correlation coefficient (`np.corrcoef`) of `by_name[state_or_trans][attribute][:]` <-> `by_name[state_or_trans]['param'][:][param_index]`
+
+    A correlation coefficient close to 1 indicates that the attribute likely depends on the value of the parameter denoted by `param_index`, if it is nearly 0, it likely does not depend on it.
+
+    If any value of `param_index` is not numeric (i.e., can not be parsed as float), this function returns 0.
+
+    :param by_name: measurements partitioned by state/transition name
+    :param state_or_trans: state or transition name
+    :param attribute: model attribute
+    :param param_index: index of parameter in `by_name[state_or_trans]['param']`
+    """
     if _all_params_are_numeric(by_name[state_or_trans], param_index):
         param_values = np.array(list((map(lambda x: x[param_index], by_name[state_or_trans]['param']))))
         try:
@@ -232,6 +248,24 @@ class ParamStats:
             for attribute in by_name[state_or_tran]['attributes']:
                 self.stats[state_or_tran][attribute] = self.compute_param_statistics(by_name, by_param, parameter_names, arg_count, state_or_tran, attribute, verbose = verbose)
 
+    def can_be_fitted(self, state_or_tran = None) -> bool:
+        """
+        Return whether a sufficient amount of distinct numeric parameter values is available, allowing a parameter-aware model to be generated.
+
+        :param state_or_tran: state or transition. If unset, returns whether any state or transition can be fitted.
+        """
+        if state_or_tran is None:
+            keys = self.stats.keys()
+        else:
+            keys = [state_or_tran]
+
+        for key in keys:
+            for param in self._parameter_names:
+                if len(list(filter(lambda n: is_numeric(n), self.distinct_values[key][param]))) > 2:
+                    print(key, param, list(filter(lambda n: is_numeric(n), self.distinct_values[key][param])))
+                    return True
+        return False
+
     def compute_param_statistics(self, by_name, by_param, parameter_names, arg_count, state_or_trans, attribute, verbose = False):
         """
         Compute standard deviation and correlation coefficient for various data partitions.
@@ -338,6 +372,108 @@ class ParamStats:
 
         return ret
 
+    def static_submodel_params(self, state_or_tran, attribute):
+        """
+        Return the union of all parameter values which decide whether another parameter influences the model or not.
+
+        I.e., the returned list of dicts contains one entry for each parameter value combination which (probably) does not have any parameter influencing the model.
+        If the current parameters matches one of these, a static sub-model built based on this subset of parameters can likely be used.
+        """
+        # TODO
+        pass
+
+    def has_codependent_parameters(self, state_or_tran: str, attribute: str, param: str) -> bool:
+        """
+        Return whether there are parameters which determine whether `param` influences `state_or_tran` `attribute` or not.
+
+        :param state_or_tran: model state or transition
+        :param attribute: model attribute
+        :param param: parameter name
+        """
+        if len(self.codependent_parameters(state_or_tran, attribute, param)):
+            return True
+        return False
+
+    def codependent_parameters(self, state_or_tran: str, attribute: str, param: str) -> list:
+        """
+        Return list of parameters which determine whether `param` influences `state_or_tran` `attribute` or not.
+
+        :param state_or_tran: model state or transition
+        :param attribute: model attribute
+        :param param: parameter name
+        """
+        if self.stats[state_or_tran][attribute]['depends_on_param'][param]:
+            return self.stats[state_or_tran][attribute]['param_data'][param]['codependent_parameters']
+        return list()
+
+    
+    def has_codependent_parameters_union(self, state_or_tran: str, attribute: str) -> bool:
+        """
+        Return whether there is a subset of parameters which decides whether `state_or_tran` `attribute` is static or parameter-dependent
+
+        :param state_or_tran: model state or transition
+        :param attribute: model attribute
+        """
+        depends_on_a_parameter = False
+        for param in self._parameter_names:
+            if self.stats[state_or_tran][attribute]['depends_on_param'][param]:
+                print('{}/{} depends on {}'.format(state_or_tran, attribute, param))
+                depends_on_a_parameter = True
+                if len(self.codependent_parameters(state_or_tran, attribute, param)) == 0:
+                    print('has no codependent parameters')
+                    # Always depends on this parameter, regardless of other parameters' values
+                    return False
+        return depends_on_a_parameter
+
+    def codependent_parameters_union(self, state_or_tran: str, attribute: str) -> list:
+        """
+        Return list of parameters which determine whether any parameter influences `state_or_tran` `attribute`.
+
+        :param state_or_tran: model state or transition
+        :param attribute: model attribute
+        """
+        codependent_parameters = set()
+        for param in self._parameter_names:
+            if self.stats[state_or_tran][attribute]['depends_on_param'][param]:
+                if len(self.codependent_parameters(state_or_tran, attribute, param)) == 0:
+                    return list(self._parameter_names)
+                for codependent_param in self.codependent_parameters(state_or_tran, attribute, param):
+                    codependent_parameters.add(codependent_param)
+        return sorted(codependent_parameters)
+
+    def codependence_by_codependent_param_values(self, state_or_tran: str, attribute: str, param: str) -> dict:
+        """
+        Return dict mapping codependent parameter values to a boolean indicating whether `param` influences `state_or_tran` `attribute`.
+
+        If a dict value is true, `attribute` depends on `param` for the corresponding codependent parameter values, otherwise it does not.
+
+        :param state_or_tran: model state or transition
+        :param attribute: model attribute
+        :param param: parameter name
+        """
+        if self.stats[state_or_tran][attribute]['depends_on_param'][param]:
+            return self.stats[state_or_tran][attribute]['param_data'][param]['depends_for_codependent_value']
+        return dict()
+
+    def codependent_parameter_value_dicts(self, state_or_tran: str, attribute: str, param: str, kind='dynamic'):
+        """
+        Return dicts of codependent parameter key-value mappings for which `param` influences (or does not influence) `state_or_tran` `attribute`.
+
+        :param state_or_tran: model state or transition
+        :param attribute: model attribute
+        :param param: parameter name:
+        :param kind: 'static' or 'dynamic'. If 'dynamic' (the default), returns codependent parameter values for which `param` influences `attribute`. If 'static', returns codependent parameter values for which `param` does not influence `attribute`
+        """
+        codependent_parameters = self.stats[state_or_tran][attribute]['param_data'][param]['codependent_parameters']
+        codependence_info = self.stats[state_or_tran][attribute]['param_data'][param]['depends_for_codependent_value']
+        if len(codependent_parameters) == 0:
+            return
+        else:
+            for param_values, is_dynamic in codependence_info.items():
+                if (is_dynamic and kind == 'dynamic') or (not is_dynamic and kind == 'static'):
+                    yield dict(zip(codependent_parameters, param_values))
+
+
     def _depends_on_param(self, corr_param, std_param, std_lut):
         if self.use_corrcoef:
             return corr_param > 0.1
@@ -381,9 +517,12 @@ class ParamStats:
         if np.all(matrix == True) or np.all(matrix == False):
             return list()
 
-        if not is_power_of_two(np.count_nonzero(matrix)):
-            # cannot be reliably reduced to a list of parameters
-            return list()
+        # Diese Abbruchbedingung scheint noch nicht so schlau zu sein...
+        # Mit wird zu viel rausgefiltert (z.B. auto_ack! -> max_retry_count in "bin/analyze-timing.py ../data/20190815_122531_nRF24_no-rx.json" nicht erkannt)
+        # Ohne wird zu wenig rausgefiltert (auch ganz viele Abhängigkeiten erkannt, bei denen eine Parameter-Abhängigketi immer unabhängig vom Wert der anderen Parameter besteht)
+        #if not is_power_of_two(np.count_nonzero(matrix)):
+        #    # cannot be reliably reduced to a list of parameters
+        #    return list()
 
         if np.count_nonzero(matrix) == 1:
             influential_parameters = list()
@@ -413,20 +552,6 @@ class ParamStats:
         influencer_parameters = self._reduce_param_matrix(dep_by_value, other_param_list)
         return influencer_parameters
 
-    def _get_codependent_parameters(self, stats, param):
-        """
-        Return list of parameters which affect whether `param` influences the model attribute described in `stats` or not.
-        """
-        safe_div = np.vectorize(lambda x,y: 0. if x == 0 else 1 - x/y)
-        ratio_by_value = safe_div(stats['lut_by_param_values'][param], stats['std_by_param_values'][param])
-        err_mode = np.seterr('ignore')
-        dep_by_value = ratio_by_value > 0.5
-        np.seterr(**err_mode)
-
-        other_param_list = list(filter(lambda x: x != param, self._parameter_names))
-        influencer_parameters = self._reduce_param_matrix(dep_by_value, other_param_list)
-        return influencer_parameters
-
     def _param_independence_ratio(self, state_or_trans: str, attribute: str, param: str) -> float:
         """
         Return the heuristic ratio of parameter independence for state_or_trans, attribute, and param.
@@ -459,21 +584,6 @@ class ParamStats:
         """
         return 1 - self._param_independence_ratio(state_or_trans, attribute, param)
 
-    def reverse_dependent_parameters(self, state_or_trans: str, attribute: str, param: str) -> list:
-        """
-        Return parameters whose value influences whether `attribute` of `state_or_trans` depends on `param` or not.
-
-        For example, a radio's TX power is only influenced by the packet length if dynamically sized payloads are enabled.
-        So reverse_dependent_parameters('TX', 'power', 'packet_length') == ['dynamic_payload_size'].
-
-        :param state_or_trans: state or transition name
-        :param attribute: model attribute
-        :param param: parameter name
-
-        :returns: list of parameters
-        """
-        return self._get_codependent_parameters(self.stats[state_or_trans][attribute], param)
-
     def _arg_independence_ratio(self, state_or_trans, attribute, arg_index):
         statistics = self.stats[state_or_trans][attribute]
         if self.use_corrcoef:
diff --git a/lib/utils.py b/lib/utils.py
index e5699da..f040638 100644
--- a/lib/utils.py
+++ b/lib/utils.py
@@ -114,6 +114,21 @@ def param_slice_eq(a, b, index):
         return True
     return False
 
+def match_parameter_values(input_param: dict, match_param: dict):
+    """
+    Check whether one of the paramaters in `input_param` has the same value in `match_param`.
+
+    :param input_param: parameter dict of a state/transition/... measurement
+    :param match_param: parameter value filter
+    :returns: True if for all parameters k in match_param: input_param[k] == match_param[k], or if match_param is None.
+    """
+    if match_param is None:
+        return True
+    for k, v in match_param.items():
+        if k in input_param and input_param[k] != v:
+            return False
+    return True
+
 def by_name_to_by_param(by_name: dict):
     """
     Convert aggregation by name to aggregation by name and parameter values.
@@ -132,6 +147,8 @@ def by_name_to_by_param(by_name: dict):
                     by_param[param_key]['isa'] = by_name[name]['isa']
             for attribute in by_name[name]['attributes']:
                 by_param[param_key][attribute].append(by_name[name][attribute][i])
+            # Required for match_parameter_valuse in _try_fits
+            by_param[param_key]['param'].append(by_name[name]['param'][i])
     return by_param
 
 def filter_aggregate_by_param(aggregate, parameters, parameter_filter):