Bio::EnsEMBL::Analysis::Runnable::BlastmiRNA

  my $blast = Bio::EnsEMBL::Analysis::Runnable::BlastmiRNA->new
     (
      -query    => $slice,
      -program  => 'wublastn',
      -database => 'embl_vertrna',
      -options  => 'hitdist=40 -cpus=1',
      -parser   => $bplitewrapper,
      -filter   => $featurefilter,
     );
  $blast->run;
  my @output =@{$blast->output};

  my ($self,$dafs_ref)=@_;
  my @dafs = @$dafs_ref; 
  @dafs = sort{$a->p_value <=> $b->p_value} @dafs;
  my $start =0;
  my @representative_sequences;
 DAFS: foreach my $daf (@dafs){
    my @cluster;
    $start++;
    next DAFS unless($daf);	
    push @cluster,$daf;
  MATCHES:  for (my $index = $start; $index <= $#dafs ; $index++){
      next MATCHES unless ($dafs[$index]);
      if ($daf->end >= $dafs[$index]->start() && $daf->start() <= $dafs[$index]->end){
	push @cluster,$dafs[$index];
	$dafs[$index] = undef;
      }
    }
    # want to pick identical full length hits by preference
    foreach my $daf ( @cluster ){
      if($daf->score >= 100 && $daf->percent_id == 100){
	push @representative_sequences, $daf;
	next DAFS;
      }
    }
    # otherwise sort by e_value
    @cluster = sort{$b->p_value <=> $a->p_value} @cluster;
    push @representative_sequences, pop @cluster;
  }
  return\@ representative_sequences;
}

1;

  my ($self,$coverage_cutoff) = @_;
  my $results = $self->results_files;
  my @daf_coverage_results;
  my $filtered_output;
  my $bplite = $self->parser->get_parsers($results);
  foreach my $blast (@{$bplite}){
      while( my $subject = $blast->nextSbjct){
	 while (my $hsp = $subject->nextHSP) {
	   my @daf_results;
	   my $hsp_length = $hsp->length."\t";
	   my $subject_length = $subject->{'LENGTH'};
	   $subject_length = 1 unless ($subject_length);
	   my $coverage = $hsp_length/$subject_length*100;
	   $coverage =~ s/\.\d+//;
	   if ($coverage_cutoff){
	     next unless($coverage > $coverage_cutoff);
	   }
	   $subject->name =~ /^\S+\s+(\w+)/;
	   my $name = $1;
	   push @daf_results, $self->parser->split_hsp($hsp,$name);
	   # add coverage into daf score
	   foreach my $daf(@daf_results){
             #####################################################################
	     # swaps strands over if blast aligns +strand genomic to -ve strand in 
	     # RFAM file. RFAM file sequences are the correct orientation whereas 
             # the genomic can be either, with unspliced DNA it becomes
	     # impossibe to tell automatically
	     if ($daf->hstrand == -1 && $daf->strand == 1){
	       $daf->strand(-1);
	       $daf->hstrand(1);
	     }
	     $daf->score($coverage);
	     $daf->external_db_id(3200);
	     push  @daf_coverage_results, $daf;
	   }
	 }
      }
    }
  return undef unless  ( @daf_coverage_results);
  my $output = $self->cluster(\@daf_coverage_results);
  $self->output($output);

  my ($self, $dir) = @_;
  $self->workdir($dir) if($dir);
  throw("Can't run ".$self." without a query sequence") 
    unless($self->query);
  $self->checkdir();
  my $filename = $self->write_seq_file();
  $self->files_to_delete($filename);
  $self->files_to_delete($self->resultsfile);
  $self->run_analysis;
  $self->parse_results;
  $self->delete_files;
  return 1;