# Build a muscle alignment factory
  $factory = Bio::Tools::Run::Alignment::Muscle->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.

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

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

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

    $self->aformat( $DEFAULTS{'AFORMAT'} );

    $self->_set_from_args(\@
        args,
        -methods => [ @MUSCLE_PARAMS, @MUSCLE_SWITCHES ],
        -create  => 1
    );

    my ($out) = $self->SUPER::_rearrange( [qw(OUTFILE_NAME)], @args );

    $self->outfile_name( $out || '' );

    $self->aformat('msf') if $self->msf;
    $self->aformat('clustalw') if $self->clw || $self->clwstrict;

    if ( defined $self->out ) {
        $self->outfile_name( $self->out );
    }

    return $self;

    return $PROGRAM_NAME;

    return $PROGRAM_DIR;

    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`;

    $string =~ /MUSCLE\s+v(\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;
    if ( defined $input ) {
        $infilename = $self->_setinput($input);
    }
    elsif ( defined $self->in ) {
        $infilename = $self->_setinput( $self->in );
    }
    else {
        $self->throw("No inputdata provided\n");
    }
    if ( !$infilename ) {
        $self->throw("Bad input data or less than 2 sequences in $input !");
    }

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

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

    my ( $self, $alnfilename, $seqsfilename ) = @_;

    # Create input file pointer
    $self->io->_io_cleanup();
    if ( $self->version ne '3.52' ) {
        $self->throw("profile does not work for this version of muscle\n");
    }
    my $infilename;
    if ( defined $alnfilename ) {
        if ( !ref $alnfilename ) {

            # check that file exists or throw
            $infilename = $alnfilename;
            unless ( -e $infilename ) { 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 muscle profile!");
            }
        }
    }
    else {
        $self->throw("No inputdata provided\n");
    }
    if ( !$infilename ) {
        $self->throw(
            "Bad input data or less than 2 sequences in $infilename !");
    }
    if ( defined $seqsfilename ) {
        if ( !ref $seqsfilename ) {

            # check that file exists or throw
            $infilename = $seqsfilename;
            unless ( -e $infilename ) { 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 muscle profile!");
            }
        }
    }
    else {
        $self->throw("No inputdata provided\n");
    }
    if ( !$infilename ) {
        $self->throw(
            "Bad input data or less than 2 sequences in $infilename !");
    }

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

    # run muscle
    $self->{_profile} = 1;
    return &_run( $self, "$alnfilename -in2 $seqsfilename", $param_string );

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

    my ( $self, $infilename, $params ) = @_;
    my $commandstring;
    if ( $self->{_profile} ) {
        $commandstring =
          $self->executable . " -profile -in1 $infilename $params";
        $self->{_profile} = 0;
    }
    else {
        $commandstring = $self->executable . " -in $infilename $params";
    }

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

    my $status  = system($commandstring);
    my $outfile = $self->outfile_name();
    if ( !-e $outfile || -z $outfile ) {
        $self->warn("Muscle 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 muscle!");
        }
        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 (@MUSCLE_PARAMS) {
        $value = $self->$attr();
        next unless ( defined $value );
        my $attr_key = lc $attr;
        $attr_key = ' -' . $attr_key;
        $param_string .= $attr_key . ' ' . $value;
    }
    for $attr (@MUSCLE_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);
    }
    $param_string .= " -out " . $self->outfile_name;

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

  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 = $muscle->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   : $muscle->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