my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_BATCHSIZE'} = $value;
  }

  return $self->{'_BATCHSIZE'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_CHOPFIRST'} = $value;
  }

  return $self->{'_CHOPFIRST'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_CHOPLAST'} = $value;
  }

  return $self->{'_CHOPLAST'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_DNADB'} = $value;
  }

  return $self->{'_DNADB'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_GENOMICSEQS'} = $value;
  }

  return $self->{'_GENOMICSEQS'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_IIDREGEXP'} = $value;
  }

  return $self->{'_IIDREGEXP'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_KEEPORDER'} = $value;
  }

  return $self->{'_KEEPORDER'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_MAXDISTANCE'} = $value;
  }

  return $self->{'_MAXDISTANCE'};

  my $self = shift;
  $self->{'_MAXMISMATCH'} = shift if (@_);

  return $self->{'_MAXMISMATCH'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_MAXSEQLENGTH'} = $value;
  }

  return $self->{'_MAXSEQLENGTH'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_MINSEQLENGTH'} = $value;
  }

  return $self->{'_MINSEQLENGTH'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_OPTIONS'} = $value;
  }

  return $self->{'_OPTIONS'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_OUTDB'} = $value;
  }

  return $self->{'_OUTDB'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_PROGRAM'} = $value;
  }

  return $self->{'_PROGRAM'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_QUERYFILE'} = $value;
  }

  return $self->{'_QUERYFILE'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_QUERYSEQS'} = $value;
  }

  return $self->{'_QUERYSEQS'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_REPEATNUMBER'} = $value;
  }

  return $self->{'_REPEATNUMBER'};

  my $self = shift;
  $self->{'_SPECOPTIONS'} = shift if (@_);

  return $self->{'_SPECOPTIONS'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_SPLITSEQS'} = $value;
  }

  return $self->{'_SPLITSEQS'};

  my ( $self, $value ) = @_;
  if ($value) {
    $self->{'_TAGCOUNT'} = $value;
  }

  return $self->{'_TAGCOUNT'};
}

1;

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_TAGTYPE'} = $value;
  }

  return $self->{'_TAGTYPE'};

  my ( $self, $value ) = @_;

  if ( defined $value ) {
    $self->{'_TMPDIR'} = $value;
  }

  return $self->{'_TMPDIR'};

  my ($self, $ditag) = @_;

  my $repeat_number = $self->REPEATNUMBER();
  #remove repetetive sequences
  if( ($ditag->sequence =~ /A{$repeat_number}/) or ($ditag->sequence =~ /T{$repeat_number}/) or
      ($ditag->sequence =~ /C{$repeat_number}/) or ($ditag->sequence =~ /G{$repeat_number}/) ){
#  if( $ditag->sequence =~ /A{$repeat_number} | T{$repeat_number} | C{$repeat_number} | G{$repeat_number}/ ){
    print "removing repetitive ditag ".($ditag->dbID)." ".($ditag->tag_count)."\n";
    $ditag = undef;
  }
  #remove too short or too long sequences
  elsif(defined($self->MINSEQLENGTH) and (length($ditag->sequence) < $self->MINSEQLENGTH)){
    print "removing short ditag ".($ditag->dbID)." ".($ditag->tag_count)."\n";
    $ditag = undef;
  }
  elsif(defined($self->MAXSEQLENGTH) and (length($ditag->sequence) > $self->MAXSEQLENGTH)){
    print "removing long ditag ".($ditag->dbID)." ".($ditag->tag_count)."\n";
    $ditag = undef;
  }
  #remove sequences with Ns
  elsif($ditag->sequence =~ /N/){
    print "removing ditag with 'N' ".($ditag->dbID)." ".($ditag->tag_count)."\n";
    $ditag = undef;
  }

  return $ditag;

  my ($self, $ditagseq, $chop_first) = @_;

  if($ditagseq =~ /^$chop_first.+$/){
    $ditagseq =  substr($ditagseq, length($chop_first), length($ditagseq)-length($chop_first));
  }

  return $ditagseq;

  my ($self, $ditagseq, $chop_last) = @_;

  if($ditagseq =~ /^$chop_last.+$/){
    $ditagseq =  substr($ditagseq, 0, length($ditagseq)-length($chop_last));
  }

  return $ditagseq;

  my ($self, $ditag, $chop_first, $chop_last) = @_;
  my $addone = 0;

  my $motherseq = $ditag->sequence;
  my $id = $ditag->dbID;

  #remove leading bases? (e.g. G from GIS tags)
  if($chop_first){
    $motherseq = $self->_chop_first($motherseq, $chop_first);
  }
  #remove trailing bases? (e.g. AA)
  if($chop_last){
    $motherseq = $self->_chop_last($motherseq, $chop_last);
  }

  #split seq in two parts, TODO: adjust for other types
  #define border
  my $cutoffpoint = (length($motherseq))/2;
  if($cutoffpoint =~ /\./){
    $addone = 1;
  }
  $cutoffpoint = int($cutoffpoint);

  #first part of seq
  my $start_A    = 0;
  my $end_A      = $cutoffpoint;
  if($addone){ $end_A++; }
  my $seqpart_A  = ">".$id."_L_".$start_A."\n";
  $seqpart_A    .= (substr($motherseq, 0, $end_A))."\n";

  #second part of seq
  my $start_B    = $cutoffpoint;
  my $seqpart_B  = ">".$id."_R_".($start_B)."\n";
  $seqpart_B    .= (substr($motherseq, $start_B))."\n";

  return($seqpart_A.$seqpart_B);

  my ( $self, $ditagfeatures ) = @_;
  my %genome_slices;
  my @cleanfeatures;
  my $sa = $self->db->get_SliceAdaptor;

  foreach my $ditagfeature (@$ditagfeatures) {

    #(re-)set analysis
    $ditagfeature->analysis($self->analysis);

    #attach slice
    my $slice_id = $ditagfeature->slice;
    if ( not exists $genome_slices{$slice_id} ) {
      print "\nTRYING TO FETCH $slice_id.";
      $genome_slices{$slice_id} = $sa->fetch_by_name($slice_id);
    }
    my $slice = $genome_slices{$slice_id};
    $ditagfeature->slice($slice);
    push(@cleanfeatures, $ditagfeature);

  }

  return\@ cleanfeatures;

  my ($self) = @_;

  my $outdb;
  my $dnadb;

  print "\nCreating OUTDB.";
  if ( $self->OUTDB && $self->DNADB) {
    $dnadb =  new Bio::EnsEMBL::DBSQL::DBAdaptor(%{ $self->OUTDB }); 

    $outdb = new Bio::EnsEMBL::DBSQL::DBAdaptor(
              %{ $self->OUTDB }, 
              -dnadb => $dnadb 
             );

  } elsif( $self->OUTDB) {
    $outdb = new Bio::EnsEMBL::DBSQL::DBAdaptor(%{ $self->OUTDB }); 
  } else {
    $outdb = $self->db;
  }

  return $outdb;

  my ($self) = @_;

  #define target
  my $target = $self->GENOMICSEQS;
  if ( -e $target ){
    if(!(-d $target)and !(-s $target)) {
      throw("'$target' isn't a file or a directory?");
    }
  } else {
    throw("'$target' could not be found");
  }

  #define query: batch of ditags, split in two
  my @fasta_entries = ();
  my $tmp_dir       = $self->TMPDIR;
  #expected format of input ids: ditag.<TYPE>.<NUMBER>
  $self->input_id   =~ /ditag\.(\S+)\.([0-9]+)/;
  my $tagtype       = $1;
  my $input_index   = $2;
  throw("Couldn t get index number from input-id ".$self->input_id)
      unless($input_index);
  throw("Couldn t get tag-type from input-id ".$self->input_id)
      unless($tagtype);

  #fetch all desired ditags
  my $batch_size = $self->BATCHSIZE();
  #my $tagtype    = $self->TAGTYPE();
  my $ditags     = $self->db->get_ditagAdaptor->fetch_all_with_limit(
                   $tagtype, $batch_size, ($batch_size * ($input_index - 1)) );
  my $chop_first = $self->CHOPFIRST();

  my $chop_last  = $self->CHOPLAST();

  foreach my $ditag (@$ditags) {
    #avoid polyA sequences
    $ditag = $self->_check_seq($ditag);
    if($ditag) {

      my $ditag_fasta_entry;
      if($self->SPLITSEQS()) {
        #split the seq and store as fasta line, remove specific bases if necessary
        $ditag_fasta_entry = $self->_split_seq($ditag, $chop_first, $chop_last);
      } else {
        my $tagseq = $ditag->sequence;
        #remove leading bases? (e.g. G from GIS tags)
        if($chop_first){
          $tagseq = $self->_chop_first($tagseq, $chop_first);
        }
        #remove trailing bases? (e.g. AA)
        if($chop_last){
          $tagseq = $self->_chop_last($tagseq, $chop_last);
        }
        $ditag_fasta_entry = ">".$ditag->dbID."_F"."\n".$tagseq."\n";
      }
      push(@fasta_entries, $ditag_fasta_entry);
    }
  }

  #write fasta lines to temp-file for exonerate
  my $tmp_file = $tmp_dir."/".$input_index.".tmp";
  open(OUTFILE, ">$tmp_file") or throw "couldnt create fasta chunk file $tmp_file";
  foreach my $ditag_fasta_entry (@fasta_entries) {
    print OUTFILE $ditag_fasta_entry;
  }
  close(OUTFILE) or throw "couldnt close fasta chunk file $tmp_file";

  #define other parameters
  my %parameters = %{ $self->parameters_hash };

  if (
    not exists( $parameters{-options} )
    and defined $self->OPTIONS
  ){
    $parameters{-options} = $self->OPTIONS;
  }

  if($self->analysis->db_file){
    $parameters{'-STS_FILE'} = $self->analysis->db_file 
      unless($parameters{'-STS_FILE'});
  }

  my $program = ($self->PROGRAM()) ? $self->PROGRAM() : $self->analysis->program_file;
  if(!$program){ throw "Cant decide what program to use for analysis!\n" }

  #create runnable
  my $runnable = Bio::EnsEMBL::Analysis::Runnable::ExonerateTags->new
    (
     -program         => $program,
     -analysis        => $self->analysis,
     -target_file     => $target,
     -query_file      => $tmp_file,
     -deletequeryfile => 0,
     -maxmismatch     => $self->MAXMISMATCH(),
     -specoptions     => $self->SPECOPTIONS(),
     -splitseqs       => $self->SPLITSEQS(),
     -maxdistance     => $self->MAXDISTANCE(),
     -keeporder       => $self->KEEPORDER(),
     %parameters
    );
  $self->runnable($runnable);

  my ( $class, @args ) = @_;
  my $self = $class->SUPER::new(@args);

  $self->read_and_check_config($DITAG_CONFIG);

  return $self;

  my ($self) = @_;
  my @out_features;

  throw("Can't run - no runnable objects") unless ( $self->runnable );

  my $runnable = @{ $self->runnable }[0];

  $runnable->run;

  @out_features = @{$runnable->output};
  $self->output(\@out_features);

  my ($self);
  return "Bio::EnsEMBL::Analysis::Runnable::DitagAlign";

  my ( $self, $ditagfeatures ) = @_;

  my $ditagfeature_adaptor;
  if($self->OUTDB) {
    my $outdb             = $self->create_output_db;
    $ditagfeature_adaptor = $outdb->get_DitagFeatureAdaptor;
  } else {
    $ditagfeature_adaptor = $self->db->get_DitagFeatureAdaptor;
  }

  if(!$ditagfeatures or !(scalar @$ditagfeatures)){
    $ditagfeatures = $self->output();
  }
  print "\nhave ".(scalar @$ditagfeatures)." features to store.\n";
  if(!$ditagfeatures or !(scalar @$ditagfeatures)){
    warn "no features to store.";
  }
  else {
    $ditagfeatures = $self->clean_features($ditagfeatures);
    #eval { $ditagfeature_adaptor->store($ditagfeatures) };
    eval { $ditagfeature_adaptor->batch_store($ditagfeatures) };
    if ($@) {
      $self->throw("Unable to store ditagFeatures!\n $@");
    }
  }

  Arg [1]   : (optional) new value
  Function  : GETTER/SETTER functions for Config values
  Returntype: string or undef
  Caller    : private