docs: def find_sample_min_max_interpretation(self, Intensities):
          '''
          find the minimum and maximum acceptable sample mean
          Intensities={}
          Intensities[specimen_name]=[] array of acceptable interpretations ( units of uT)
          '''
          # acceptance criteria
          if self.acceptance_criteria['average_by_sample_or_site']['value'] == 'sample':
              int_n_cutoff = self.acceptance_criteria['sample_int_n']['value']
              int_sigma_cutoff = self.acceptance_criteria['sample_int_sigma']['value']
              int_sigma_perc_cutoff = self.acceptance_criteria['sample_int_sigma_perc']['value']
          else:
              int_n_cutoff = self.acceptance_criteria['site_int_n']['value']
              int_sigma_cutoff = self.acceptance_criteria['site_int_sigma']['value']
              int_sigma_perc_cutoff = self.acceptance_criteria['site_int_sigma_perc']['value']
          if int_n_cutoff == -999:
              int_n_cutoff = 2
          # if int_sigma_cutoff==-999:
          #    int_sigma_cutoff=999
          # if int_sigma_perc_cutoff==-999:
          #    int_sigma_perc_cutoff=999
  
          # make a new dictionary named "tmp_Intensities" with all grade A
          # interpretation sorted.
          tmp_Intensities = {}
          Acceptable_sample_min_mean, Acceptable_sample_max_mean = "", ""
          for this_specimen in list(Intensities.keys()):
              B_list = [B for B in Intensities[this_specimen]]
              if len(B_list) > 0:
                  B_list.sort()
                  tmp_Intensities[this_specimen] = B_list
  
          # find the minmum acceptable values
          while len(list(tmp_Intensities.keys())) >= int_n_cutoff:
              B_tmp = []
              B_tmp_min = 1e10
              for specimen in list(tmp_Intensities.keys()):
                  B_tmp.append(min(tmp_Intensities[specimen]))
                  if min(tmp_Intensities[specimen]) < B_tmp_min:
                      specimen_to_remove = specimen
                      B_tmp_min = min(tmp_Intensities[specimen])
              pass_or_fail = self.pass_or_fail_sigma(
                  B_tmp, int_sigma_cutoff, int_sigma_perc_cutoff)
              if pass_or_fail == 'pass':
                  Acceptable_sample_min_mean = mean(B_tmp)
                  Acceptable_sample_min_std = std(B_tmp, ddof=1)
                  # print "min
                  # value,std,",mean(B_tmp),std(B_tmp),100*(std(B_tmp)/mean(B_tmp))
                  break
              else:
                  tmp_Intensities[specimen_to_remove].remove(B_tmp_min)
                  if len(tmp_Intensities[specimen_to_remove]) == 0:
                      break
  
          tmp_Intensities = {}
          for this_specimen in list(Intensities.keys()):
              B_list = [B for B in Intensities[this_specimen]]
              if len(B_list) > 0:
                  B_list.sort()
                  tmp_Intensities[this_specimen] = B_list
  
          while len(list(tmp_Intensities.keys())) >= int_n_cutoff:
              B_tmp = []
              B_tmp_max = 0
              for specimen in list(tmp_Intensities.keys()):
                  B_tmp.append(max(tmp_Intensities[specimen]))
                  if max(tmp_Intensities[specimen]) > B_tmp_max:
                      specimen_to_remove = specimen
                      B_tmp_max = max(tmp_Intensities[specimen])
  
              pass_or_fail = self.pass_or_fail_sigma(
                  B_tmp, int_sigma_cutoff, int_sigma_perc_cutoff)
              if pass_or_fail == 'pass':
                  # if std(B_tmp,ddof=1)<=int_sigma_cutoff*1e6 or
                  # 100*(std(B_tmp,ddof=1)/mean(B_tmp))<=int_sigma_perc_cutoff:
                  Acceptable_sample_max_mean = mean(B_tmp)
                  Acceptable_sample_max_std = std(B_tmp, ddof=1)
                  # print "max
                  # value,std,",mean(B_tmp),std(B_tmp),100*(std(B_tmp)/mean(B_tmp))
  
                  break
              else:
                  tmp_Intensities[specimen_to_remove].remove(B_tmp_max)
                  if len(tmp_Intensities[specimen_to_remove]) < 1:
                      break
  
          if Acceptable_sample_min_mean == "" or Acceptable_sample_max_mean == "":
              return(0., 0., 0., 0.)
          return(Acceptable_sample_min_mean, Acceptable_sample_min_std, Acceptable_sample_max_mean, Acceptable_sample_max_std)