# Build a muscle alignment factory
  $factory = Bio::Tools::Run::Alignment::Probalign->new(@params);

  # Pass the factory a list of sequences to be aligned.
  $inputfilename = 't/cysprot.fa';
  # $aln is a SimpleAlign object.
  $aln = $factory->align($inputfilename);

  # or where @seq_array is an array of Bio::Seq objects
  $seq_array_ref = \@seq_array;
  $aln = $factory->align($seq_array_ref);

  # Or one can pass the factory a pair of (sub)alignments
  #to be aligned against each other, e.g.:

  #There are various additional options and input formats available.
  #See the DESCRIPTION section that follows for additional details.

  $factory = Bio::Tools::Run::Alignment::Probalign->new();
  $factory->outfile_name("$dir/$subdir/$outdir/outfile.afa");
  $aln = $factory->align($seq_array_ref);

  1. Make sure the probalign executable is in your path (i.e. 
     'which probalign' returns a valid program
  2. define an environmental variable PROBALIGNDIR which points to a 
     directory containing the 'probalign' app:
   In bash 
	export PROBALIGNDIR=/home/progs/probalign   or
   In csh/tcsh
        setenv PROBALIGNDIR /home/progs/probalign

  3. include a definition of an environmental variable PROBALIGNDIR 
      in every script that will
     BEGIN {$ENV{PROBALIGNDIR} = '/home/progs/probalign'; }
     use Bio::Tools::Run::Alignment::Probalign;

    %DEFAULTS = ( 'AFORMAT' => 'fasta' );
    @PROBALIGN_PARAMS = qw (TEMPERATURE SCORE_MATRIX GAP-OPEN GAP-EXTENSION); 
    @PROBALIGN_SWITCHES = qw(CLUSTALW VERBOSE ALIGNMENT-ORDER NUC PROT);
    @OTHER_SWITCHES = qw();

# Authorize attribute fields
    foreach my $attr ( @PROBALIGN_PARAMS, @PROBALIGN_SWITCHES, @OTHER_SWITCHES ) {
	$OK_FIELD{$attr}++;

        return 'probalign';

        return Bio::Root::IO->catfile($ENV{PROBALIGNDIR}) if $ENV{PROBALIGNDIR};

    my ($class,@args) = @_;
    my $self = $class->SUPER::new(@args);
    my ($on) = $self->SUPER::_rearrange([qw(OUTFILE_NAME)], @args);
    $self->outfile_name($on || '');
    my ($attr, $value);
    $self->aformat($DEFAULTS{'AFORMAT'});

    while ( @args)  {
	$attr =   shift @args;
	$value =  shift @args;
	next if( $attr =~ /^-/); # don't want named parameters
	$self->$attr($value);
    }
    return $self;

    my $self = shift;
    my $attr = $AUTOLOAD;
    $attr =~ s/.*:://;
    $attr = uc $attr;
    # aliasing
    $self->throw("Unallowed parameter: $attr !") unless $OK_FIELD{$attr};

    $self->{$attr} = shift if @_;
    return $self->{$attr};

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

    my ($self) = @_;
    my $exe;
    return undef unless $exe = $self->executable;
    my $string = `$exe 2>&1` ;
    #PROBALIGN version 1.09 - align multiple protein sequences and print to standard output
    $string =~ /PROBALIGN\s+Beta\s+Version\s+(\d+\.\d+)/m;
    return $1 || undef;

    my $self = shift;
    return $self->align(shift);

    my ($self,$input) = @_;
    # Create input file pointer
    $self->io->_io_cleanup();
    my ($infilename) = $self->_setinput($input);
    if (! $infilename) {
	$self->throw("Bad input data or less than 2 sequences in $input !");
    }

    my $param_string = $self->_setparams();

    # run probalign
    return &_run($self, $infilename, $param_string);

    my ($self,$infilename,$params) = @_;
    my $commandstring = $self->executable." $infilename $params";

    $self->debug( "probalign command = $commandstring\n ");

    my $status = system($commandstring);
    my $outfile = $self->outfile_name(); 

    if( !-e $outfile || -z $outfile ) {
	$self->warn( "Probalign call crashed: $? [command $commandstring]\n");
	return undef;
    }

    my $in  = Bio::AlignIO->new('-file'   => $outfile, 
				'-format' => $self->aformat);
    my $aln = $in->next_aln();
    return $aln;

    my ($self,$input) = @_;
    my ($infilename, $seq, $temp, $tfh);
    if (! ref $input) {
	# check that file exists or throw
	$infilename = $input;
	unless (-e $input) {return 0;}
	# let's peek and guess
	open(IN,$infilename) || $self->throw("Cannot open $infilename");
	my $header;
	while( defined ($header = <IN>) ) {
	    last if $header !~ /^\s+$/;
	}
	close(IN);
	if ( $header !~ /^>\s*\S+/ ){
	    $self->throw("Need to provide a FASTA format file to probalign!");
	} 
	return ($infilename);
    } elsif (ref($input) =~ /ARRAY/i ) { #  $input may be an
	#  array of BioSeq objects...
        #  Open temporary file for both reading & writing of array
	($tfh,$infilename) = $self->io->tempfile();
	if( ! ref($input->[0]) ) {
	    $self->warn("passed an array ref which did not contain objects to _setinput");
	    return undef;
	} elsif( $input->[0]->isa('Bio::PrimarySeqI') ) {
	    $temp =  Bio::SeqIO->new('-fh' => $tfh,
				     '-format' => 'fasta');
	    my $ct = 1;
	    foreach $seq (@$input) {
		return 0 unless ( ref($seq) && 
				  $seq->isa("Bio::PrimarySeqI") );
		if( ! defined $seq->display_id ||
		    $seq->display_id =~ /^\s+$/) {
		    $seq->display_id( "Seq".$ct++);
		} 
		$temp->write_seq($seq);
	    }
	    $temp->close();
	    undef $temp;
	    close($tfh);
	    $tfh = undef;
	} else { 
	    $self->warn( "got an array ref with 1st entry ".
			 $input->[0].
			 " and don't know what to do with it\n");
	}
	return ($infilename);
    } else { 
	$self->warn("Got $input and don't know what to do with it\n");
    }
    return 0;

    my ($self) = @_;
    my ($attr, $value,$param_string);
    $param_string = '';
    my $laststr;
    for  $attr ( @PROBALIGN_PARAMS ) {
	$value = $self->$attr();
	next unless (defined $value);	
	my $attr_key = lc $attr;
        $attr_key = ' --'.$attr_key unless ($attr eq 'ANNOT');
        $attr_key = ' -'.$attr_key if ($attr eq 'ANNOT');
        $param_string .= $attr_key .' '.$value;

    }
    for  $attr ( @PROBALIGN_SWITCHES) {
	$value = $self->$attr();
	next unless ($value);
	my $attr_key = lc $attr; #put switches in format expected by tcoffee
	$attr_key = ' -'.$attr_key;
	$param_string .= $attr_key ;
    }
    # Set default output file if no explicit output file selected
    unless ($self->outfile_name ) {	
	my ($tfh, $outfile) = $self->io->tempfile(-dir=>$self->tempdir());
	close($tfh);
	undef $tfh;
	$self->outfile_name($outfile);
    }
    #FIXME: This may be only for *nixes. Double check in other OSes
    $param_string .= " > ".$self->outfile_name;

    if ($self->verbose < 0) { 
	$param_string .= ' 2> /dev/null';
    }
    return $param_string;

    my $self = shift;
    $self->{'_aformat'} = shift if @_;
    return $self->{'_aformat'};

  bioperl-l@bioperl.org                  - General discussion
  http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

 http://redmine.open-bio.org/projects/bioperl/

 Title   : no_param_checks
 Usage   : $obj->no_param_checks($newval)
 Function: Boolean flag as to whether or not we should
           trust the sanity checks for parameter values
 Returns : value of no_param_checks
 Args    : newvalue (optional)

 Title   : save_tempfiles
 Usage   : $obj->save_tempfiles($newval)
 Function: 
 Returns : value of save_tempfiles
 Args    : newvalue (optional)

 Title   : outfile_name
 Usage   : my $outfile = $probalign->outfile_name();
 Function: Get/Set the name of the output file for this run
           (if you wanted to do something special)
 Returns : string
 Args    : [optional] string to set value to

 Title   : tempdir
 Usage   : my $tmpdir = $self->tempdir();
 Function: Retrieve a temporary directory name (which is created)
 Returns : string which is the name of the temporary directory
 Args    : none

 Title   : cleanup
 Usage   : $probalign->cleanup();
 Function: Will cleanup the tempdir directory
 Returns : none
 Args    : none

 Title   : io
 Usage   : $obj->io($newval)
 Function:  Gets a Bio::Root::IO object
 Returns : Bio::Root::IO
 Args    : none