docs: def generate_recurrence_models(
              self, collapse=False, bin_width=0.1,
              config=None, rendered_msr=None):
          '''
          Iterates over the lists of values defining epistemic uncertainty
          in the parameters and calculates the corresponding recurrence model
          At present epistemic uncertainty is supported for: 1) slip rate,
          2) magnitude scaling relation, 3) shear modulus, 4) displacement
          to length ratio) and 5) recurrence model.
  
          :param list config:
              List of MFD model configurations
          :param bool collapse:
              Boolean flag indicating whether to collapse the logic tree branches
          :param float bin_width:
              If collapsing the logic tree branches the reference mfd must be
              defined. The minimum and maximum magnitudes are updated from the
              model, but the bin width must be specified here
          :param list/dict config:
              Configuration (or sets of configurations) of the recurrence
              calculations
          :param rendered_msr:
              If collapsing the logic tree branches a resulting magnitude
              scaling relation must be defined as instance of
              :class: openquake.hazardlib.scalerel.base.BaseASR
          '''
          if collapse and not rendered_msr:
              raise ValueError('Collapsing logic tree branches requires input '
                               'of a single msr for rendering sources')
  
          # Generate a set of tuples with corresponding weights
          if config is not None:
              self.generate_config_set(config)
          if not isinstance(self.config, list):
              raise ValueError('MFD configuration missing or incorrectly '
                               'formatted')
  
          # Generate the branching index
          branch_index, _number_branches = self._generate_branching_index()
          mmin = np.inf
          mmax = -np.inf
          for idx in branch_index:
              tuple_list = []
              # Get slip
              tuple_list.append(self.slip[idx[0]])
              # Get msr
              tuple_list.append(self.msr[idx[1]])
              # Get shear modulus
              tuple_list.append(self.shear_modulus[idx[2]])
              # Get displacement length ratio
              tuple_list.append(self.disp_length_ratio[idx[3]])
              # Get msr sigma
              tuple_list.append(self.msr_sigma[idx[4]])
              # Get config
              tuple_list.append(self.config[idx[5]])
              # Calculate branch weight as product of tuple weights
              branch_weight = np.prod(np.array([val[1] for val in tuple_list]))
              # Instantiate recurrence model
              model = RecurrenceBranch(self.area,
                                       tuple_list[0][0],
                                       tuple_list[1][0],
                                       self.rake,
                                       tuple_list[2][0],
                                       tuple_list[3][0],
                                       tuple_list[4][0],
                                       weight=branch_weight)
              model.get_recurrence(tuple_list[5][0])
              self.mfd_models.append(model)
              # Update the total minimum and maximum magnitudes for the fault
              if model.recurrence.min_mag < mmin:
                  mmin = model.recurrence.min_mag
              if np.max(model.magnitudes) > mmax:
                  mmax = np.max(model.magnitudes)
          if collapse:
              self.mfd = ([self.collapse_branches(mmin, bin_width, mmax)],
                          [1.0],
                          [rendered_msr])
          else:
              mfd_mods = []
              mfd_wgts = []
              mfd_msr = []
              for model in self.mfd_models:
                  mfd_mods.append(IncrementalMFD(model.recurrence.min_mag,
                                                 model.recurrence.bin_width,
                                                 model.recurrence.occur_rates))
                  mfd_wgts.append(model.weight)
                  mfd_msr.append(model.msr)
              self.mfd = (mfd_mods, mfd_wgts, mfd_msr)