docs: def summarise(self, base_list, trusted_placements, reverse_pipe, times,
                    hit_read_count_list, max_samples_for_krona):
          '''
          summarise - write summary information to file, including otu table, biom
                      file, krona plot, and timing information
  
          Parameters
          ----------
          base_list : array
              list of each of the files processed by graftm, with the path and
              and suffixed removed
          trusted_placements : dict
              dictionary of placements with entry as the key, a taxonomy string
              as the value
          reverse_pipe : bool
              True = run reverse pipe, False = run normal pipeline
          times : array
              list of the recorded times for each step in the pipeline in the
              format: [search_step_time, alignment_step_time, placement_step_time]
          hit_read_count_list : array
              list containing sublists, one for each file run through the GraftM
              pipeline, each two entries, the first being the number of putative
              eukaryotic reads (when searching 16S), the second being the number
              of hits aligned and placed in the tree.
          max_samples_for_krona: int
              If the number of files processed is greater than this number, then
              do not generate a krona diagram.
          Returns
          -------
          '''
  
          # Summary steps.
          placements_list = []
          for base in base_list:
              # First assign the hash that contains all of the trusted placements
              # to a variable to it can be passed to otu_builder, to be written
              # to a file. :)
              placements = trusted_placements[base]
              self.s.readTax(placements, GraftMFiles(base, self.args.output_directory, False).read_tax_output_path(base))
              placements_list.append(placements)
  
          #Generate coverage table
          #logging.info('Building coverage table for %s' % base)
          #self.s.coverage_of_hmm(self.args.aln_hmm_file,
          #                         self.gmf.summary_table_output_path(base),
          #                         self.gmf.coverage_table_path(base),
          #                         summary_dict[base]['read_length'])
  
          logging.info('Writing summary table')
          with open(self.gmf.combined_summary_table_output_path(), 'w') as f:
              self.s.write_tabular_otu_table(base_list, placements_list, f)
  
          logging.info('Writing biom file')
          with biom_open(self.gmf.combined_biom_output_path(), 'w') as f:
              biom_successful = self.s.write_biom(base_list, placements_list, f)
          if not biom_successful:
              os.remove(self.gmf.combined_biom_output_path())
  
          logging.info('Building summary krona plot')
          if len(base_list) > max_samples_for_krona:
              logging.warn("Skipping creation of Krona diagram since there are too many input files. The maximum can be overridden using --max_samples_for_krona")
          else:
              self.s.write_krona_plot(base_list, placements_list, self.gmf.krona_output_path())
  
          # Basic statistics
          placed_reads=[len(trusted_placements[base]) for base in base_list]
          self.s.build_basic_statistics(times, hit_read_count_list, placed_reads, \
                                        base_list, self.gmf.basic_stats_path())
  
          # Delete unnecessary files
          logging.info('Cleaning up')
          for base in base_list:
              directions = ['forward', 'reverse']
              if reverse_pipe:
                  for i in range(0,2):
                      self.gmf = GraftMFiles(base, self.args.output_directory, directions[i])
                      self.hk.delete([self.gmf.for_aln_path(base),
                                      self.gmf.rev_aln_path(base),
                                      self.gmf.conv_output_rev_path(base),
                                      self.gmf.conv_output_for_path(base),
                                      self.gmf.euk_free_path(base),
                                      self.gmf.euk_contam_path(base),
                                      self.gmf.readnames_output_path(base),
                                      self.gmf.sto_output_path(base),
                                      self.gmf.orf_titles_output_path(base),
                                      self.gmf.orf_output_path(base),
                                      self.gmf.output_for_path(base),
                                      self.gmf.output_rev_path(base)])
              else:
                  self.gmf = GraftMFiles(base, self.args.output_directory, False)
                  self.hk.delete([self.gmf.for_aln_path(base),
                                  self.gmf.rev_aln_path(base),
                                  self.gmf.conv_output_rev_path(base),
                                  self.gmf.conv_output_for_path(base),
                                  self.gmf.euk_free_path(base),
                                  self.gmf.euk_contam_path(base),
                                  self.gmf.readnames_output_path(base),
                                  self.gmf.sto_output_path(base),
                                  self.gmf.orf_titles_output_path(base),
                                  self.gmf.orf_output_path(base),
                                  self.gmf.output_for_path(base),
                                  self.gmf.output_rev_path(base)])
  
          logging.info('Done, thanks for using graftM!\n')