| dafeef0b |
/* -*- mode: c; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*********************************************************************
* Clustal Omega - Multiple sequence alignment
*
* Copyright (C) 2010 University College Dublin
*
* Clustal-Omega is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This file is part of Clustal-Omega.
*
********************************************************************/
/*
* RCS $Id: mymain.c 285 2013-06-12 11:45:17Z fabian $
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include "argtable2/argtable2.h"
#include <ctype.h>
#include <limits.h>
#include <libgen.h> /* for basename only */
/* clustal */
#include "clustal-omega.h"
#include "mymain.h"
#include "exceptions4c/e4c_lite.h"
typedef struct {
/* Sequence input
*/
/** sequence type (from cmdline arg) */
int iSeqType;
/** sequence input file. not directly used by Align() */
char *pcSeqInfile;
/** Dealign sequences on input. Otherwise we use the alignment
* info for background-HMM creation */
bool bDealignInputSeqs;
/** Sequence input format
*/
int iSeqInFormat;
/* profiles: : pre-aligned sequences, whose alignment will not be changed
*/
/** profile 1: pre-aligned sequence input. not directly used by Align() */
char *pcProfile1Infile ;
/** profile 2: pre-aligned sequence input. not directly used by Align() */
char *pcProfile2Infile;
/** profiles that contain no gaps are rejected, force them */
bool bIsProfile;
/** up to version 1.1.1 Kimura distance was default, change default, make Kimura optional */
//bool bUseKimura;
/** distance matrix output is default, allow %-ID output */
bool bPercentID;
/** Input limitations
*/
/** maximum allowed number of input sequences */
int iMaxNumSeq;
/** maximum allowed input sequence length */
int iMaxSeqLen;
/* Alignment output
*/
/** alignment output file */
char *pcAlnOutfile;
/** alignment output format */
int iAlnOutFormat;
/** force overwriting of files */
bool bForceFileOverwrite;
/** force sequence from R */
bool bRSequence;
/* line wrapping, FS, r274 -> */
int iWrap;
/* residue number in Clustal format, FS, r274 -> */
bool bResno;
/* output order, FS, r274 -> */
int iOutputOrder;
/* multithreading
*/
/** number of threads */
int iThreads;
/* logging
*/
char *pcLogFile;
opts_t aln_opts;
/* changes here will have to be reflected in SetDefaultUserOpts(),
* FreeUserOpts(), PrintUserOpts() and UserOptsLogicCheck() etc
*/
} cmdline_opts_t;
/* log-file used for non-essential logging in prLog */
FILE *prLogFile = NULL;
const char *CITATION = " Sievers F, Wilm A, Dineen D, Gibson TJ, Karplus K, Li W, Lopez R, McWilliam H, Remmert M, Söding J, Thompson JD, Higgins DG."
"\n"
" Fast, scalable generation of high-quality protein multiple sequence alignments using Clustal Omega."
"\n"
" Mol Syst Biol. 2011 Oct 11;7:539. doi: 10.1038/msb.2011.75. PMID: 21988835.";
/**
* @brief Sets default user/commandline options
*
* @param[out] opts
* The option structure to initialise
*
*/
void
SetDefaultUserOpts(cmdline_opts_t *opts)
{
assert(NULL != opts);
opts->iSeqType = SEQTYPE_UNKNOWN;
opts->pcSeqInfile = NULL;
opts->bDealignInputSeqs = FALSE;
opts->pcProfile1Infile = NULL;
opts->pcProfile2Infile = NULL;
opts->bIsProfile = FALSE;
opts->aln_opts.bUseKimura = FALSE;
opts->aln_opts.bPercID = FALSE;
opts->iMaxNumSeq = INT_MAX;
opts->iMaxSeqLen = INT_MAX;
opts->pcAlnOutfile = NULL;
opts->iAlnOutFormat = MSAFILE_A2M;
opts->bForceFileOverwrite = FALSE;
opts->bRSequence = FALSE;
opts->iWrap = 60;
opts->bResno = FALSE;
opts->iOutputOrder = INPUT_ORDER;
#ifdef WIN32
opts->iThreads = 1;
#elif HAVE_OPENMP
/* defaults to # of CPUs */
opts->iThreads = omp_get_max_threads();
#else
opts->iThreads = 1;
#endif
opts->pcLogFile = NULL;
SetDefaultAlnOpts(& opts->aln_opts);
}
/* end of SetDefaultUserOpts() */
/**
* @brief FIXME add doc
*
*/
void
PrintUserOpts(FILE *prFile, cmdline_opts_t *opts) {
/* keep in same order as in struct. FIXME could this be derived from argtable?
*/
fprintf(prFile, "seq-type = %s\n", SeqTypeToStr(opts->iSeqType));
fprintf(prFile, "seq-in-fmt = %s\n", SeqfileFormat2String(opts->iSeqInFormat));
fprintf(prFile, "option: seq-in = %s\n",
NULL != opts->pcSeqInfile? opts->pcSeqInfile: "(null)");
fprintf(prFile, "option: dealign = %d\n", opts->bDealignInputSeqs);
fprintf(prFile, "option: profile1 = %s\n",
NULL != opts->pcProfile1Infile? opts->pcProfile1Infile: "(null)");
fprintf(prFile, "option: profile2 = %s\n",
NULL != opts->pcProfile2Infile? opts->pcProfile2Infile: "(null)");
//fprintf(prFile, "option: percent-id = %d\n", opts->bPercID);
fprintf(prFile, "option: is-profile = %d\n", opts->bIsProfile);
//fprintf(prFile, "option: use-kimura = %d\n", opts->aln_opts.bUseKimura);
fprintf(prFile, "option: max-num-seq = %d\n", opts->iMaxNumSeq);
fprintf(prFile, "option: max-seq-len = %d\n", opts->iMaxSeqLen);
fprintf(prFile, "option: aln-out-file = %s\n",
NULL != opts->pcAlnOutfile? opts->pcAlnOutfile: "(null)");
fprintf(prFile, "option: aln-out-format = %s\n", SeqfileFormat2String(opts->iAlnOutFormat));
fprintf(prFile, "option: force-file-overwrite = %d\n", opts->bForceFileOverwrite);
fprintf(prFile, "option: sequence from R = %d\n", opts->bRSequence);
fprintf(prFile, "option: line wrap = %d\n", opts->iWrap);
fprintf(prFile, "option: print residue numbers = %d\n", opts->bResno);
fprintf(prFile, "option: order alignment like input/tree = %d\n", opts->iOutputOrder);
fprintf(prFile, "option: threads = %d\n", opts->iThreads);
fprintf(prFile, "option: logFile = %s\n", opts->pcLogFile);
}
/* end of PrintUserOpts */
/**
* @brief Frees user opt members allocated during parsing
*
* @param[out] user_opts
* user options whose members are to free
*
* @see ParseCommandLine()
*
*/
void
FreeUserOpts(cmdline_opts_t *user_opts)
{
if (NULL != user_opts->pcSeqInfile) {
CKFREE(user_opts->pcSeqInfile);
}
if (NULL != user_opts->pcProfile1Infile) {
CKFREE(user_opts->pcProfile1Infile);
}
if (NULL != user_opts->pcProfile2Infile) {
CKFREE(user_opts->pcProfile2Infile);
}
if (NULL != user_opts->pcAlnOutfile) {
CKFREE(user_opts->pcAlnOutfile);
}
if (NULL != user_opts->pcLogFile) {
CKFREE(user_opts->pcLogFile);
}
FreeAlnOpts(& user_opts->aln_opts);
return;
}
/* end of FreeUserOpts() */
/**
* @brief Do quick&dirty logic check of used options and call Log(&rLog, LOG_FATAL, ) in case
* of any inconsistencies
*
* @param[in] opts
* option structure to check
*
*/
void
UserOptsLogicCheck(cmdline_opts_t *opts)
{
/* sequence input
*
*/
if (NULL == opts->pcSeqInfile && !opts->bRSequence) {
if (NULL == opts->pcProfile1Infile && NULL == opts->pcProfile2Infile) {
Log(&rLog, LOG_FATAL, "No sequence input was provided. For more information try: --help");
}
} else {
if (NULL != opts->pcProfile1Infile && NULL != opts->pcProfile2Infile) {
Log(&rLog, LOG_FATAL, "Can't align two profile alignments AND a 'normal' sequence file");
}
}
/* if a profile was given it should always be no 1, not 2 */
if (NULL == opts->pcProfile1Infile && NULL != opts->pcProfile2Infile) {
Log(&rLog, LOG_FATAL, "Got a second profile, but no first one.");
}
/* alignment output
*/
if (rLog.iLogLevelEnabled < LOG_WARN && NULL==opts->pcAlnOutfile && NULL==opts->pcLogFile) {
Log(&rLog, LOG_FATAL, "%s %s",
"You requested alignment output to stdout and verbose logging.",
" Alignment and log messages would get mixed up.");
}
/* distance matrix output impossible in mBed mode, only have clusters, FS, r254 -> */
#if 1
/* allow distance matrix output if initial mBed but subsequent full matrix during iteration, FS, r274 -> */
if (NULL != opts->aln_opts.pcDistmatOutfile){
if ( (TRUE == opts->aln_opts.bUseMbed) && (opts->aln_opts.iNumIterations < 1) ){
Log(&rLog, LOG_FATAL, "Distance Matrix output not possible in mBed mode.");
}
if ( (TRUE == opts->aln_opts.bUseMbed) && (TRUE == opts->aln_opts.bUseMbedForIteration) ){
Log(&rLog, LOG_FATAL, "Distance Matrix output not possible in mBed mode.");
}
if ( (TRUE == opts->aln_opts.bUseMbed) && (opts->aln_opts.iNumIterations > 0) &&
(opts->aln_opts.iMaxGuidetreeIterations < 1) ){
Log(&rLog, LOG_FATAL, "Distance Matrix output not possible in mBed mode.");
}
}
#else
if ( (NULL != opts->aln_opts.pcDistmatOutfile) && (TRUE == opts->aln_opts.bUseMbed) ) {
Log(&rLog, LOG_FATAL, "Distance Matrix output not possible in mBed mode.");
}
#endif
/* percentage identity cannot be printed in Kimura mode */
if ( (TRUE == opts->aln_opts.bUseKimura) && (TRUE == opts->aln_opts.bPercID) ){
Log(&rLog, LOG_FATAL, "Percentage Identity cannot be calculated if Kimura Distances are used.");
}
AlnOptsLogicCheck(& opts->aln_opts);
}
/* end of UserOptsLogicCheck */
/**
* @brief Parse command line parameters. Will exit if help/usage etc
* are called or or call Log(&rLog, LOG_FATAL, ) if an error was detected.
*
* @param[out] user_opts
* User parameter struct, with defaults already set.
* @param[in] argc
* mains argc
* @param[in] argv
* mains argv
*
*/
void
ParseCommandLine(cmdline_opts_t *user_opts, int argc, char **argv)
{
/* argtable command line parsing:
* see
* http://argtable.sourceforge.net/doc/argtable2-intro.html
*
* basic structure is: arg_xxxN:
* xxx can be int, lit, db1, str, rex, file or date
* If N = 0, arguments may appear zero-or-once; N = 1 means
* exactly once, N = n means up to maxcount times
*
*
* @note: changes here, might also affect main.cpp:ConvertOldCmdLine()
*
*/
struct arg_rem *rem_seq_input = arg_rem(NULL, "\nSequence Input:");
struct arg_file *opt_seqin = arg_file0("i", "in,infile",
"{<file>,-}",
"Multiple sequence input file (- for stdin)");
struct arg_file *opt_hmm_in = arg_filen(NULL, "hmm-in", "<file>",
/*min*/ 0, /*max*/ 128,
"HMM input files");
struct arg_lit *opt_dealign = arg_lit0(NULL, "dealign",
"Dealign input sequences");
struct arg_file *opt_profile1 = arg_file0(NULL, "profile1,p1",
"<file>",
"Pre-aligned multiple sequence file (aligned columns will be kept fix)");
struct arg_file *opt_profile2 = arg_file0(NULL, "profile2,p2",
"<file>",
"Pre-aligned multiple sequence file (aligned columns will be kept fix)");
struct arg_lit *opt_isprofile = arg_lit0(NULL, "is-profile",
"disable check if profile, force profile (default no)");
struct arg_str *opt_seqtype = arg_str0("t", "seqtype",
"{Protein, RNA, DNA}",
"Force a sequence type (default: auto)");
/* struct arg_lit *opt_force_protein = arg_lit0(NULL, "protein",
"Set sequence type to protein even if Clustal guessed nucleic acid"); */
struct arg_str *opt_infmt = arg_str0(NULL, "infmt",
"{a2m=fa[sta],clu[stal],msf,phy[lip],selex,st[ockholm],vie[nna]}",
"Forced sequence input file format (default: auto)");
struct arg_lit *opt_resno = arg_lit0(NULL, "residuenumber,resno",
"in Clustal format print residue numbers (default no)");
struct arg_rem *rem_guidetree = arg_rem(NULL, "\nClustering:");
struct arg_str *opt_pairdist = arg_str0("p", "pairdist",
"{ktuple}",
"Pairwise alignment distance measure");
struct arg_file *opt_distmat_in = arg_file0(NULL, "distmat-in",
"<file>",
"Pairwise distance matrix input file (skips distance computation)");
struct arg_file *opt_distmat_out = arg_file0(NULL, "distmat-out",
"<file>",
"Pairwise distance matrix output file");
struct arg_file *opt_guidetree_in = arg_file0(NULL, "guidetree-in",
"<file>",
"Guide tree input file (skips distance computation and guide-tree clustering step)");
struct arg_file *opt_guidetree_out = arg_file0(NULL, "guidetree-out",
"<file>",
"Guide tree output file");
struct arg_dbl *opt_gapopen = arg_dbl0(NULL, "gapopen", "<double>", "Gap opening, default: 6 (bit)");
struct arg_dbl *opt_gapext = arg_dbl0(NULL, "gapext", "<double>", "Gap extension, default: 1 (bit)");
/* AW: mbed is default since at least R253
struct arg_lit *opt_mbed = arg_lit0(NULL, "mbed",
"Fast, Mbed-like clustering for guide-tree calculation");
struct arg_lit *opt_mbed_iter = arg_lit0(NULL, "mbed-iter",
"Use Mbed-like clustering also during iteration");
*/
/* Note: might be better to use arg_str (mbed=YES/NO) but I don't want to introduce an '=' into pipeline, FS, r250 -> */
struct arg_lit *opt_full = arg_lit0(NULL, "full",
"Use full distance matrix for guide-tree calculation (might be slow; mBed is default)");
struct arg_lit *opt_full_iter = arg_lit0(NULL, "full-iter",
"Use full distance matrix for guide-tree calculation during iteration (might be slowish; mBed is default)");
struct arg_int *opt_clustersize = arg_int0(NULL, "cluster-size", "<n>",
"soft maximum of sequences in sub-clusters"); /* FS, r274 -> */
struct arg_file *opt_clustfile = arg_file0(NULL, "clustering-out",
"<file>",
"Clustering output file"); /* FS, r274 -> */
struct arg_lit *opt_usekimura = arg_lit0(NULL, "use-kimura",
"use Kimura distance correction for aligned sequences (default no)");
struct arg_lit *opt_percentid = arg_lit0(NULL, "percent-id",
"convert distances into percent identities (default no)");
struct arg_str *opt_clustering = arg_str0("c", "clustering",
"{UPGMA}",
"Clustering method for guide tree");
struct arg_rem *rem_aln_output = arg_rem(NULL, "\nAlignment Output:");
struct arg_file *opt_outfile = arg_file0("o", "out,outfile",
"{file,-}",
"Multiple sequence alignment output file (default: stdout)");
struct arg_str *opt_outfmt = arg_str0(NULL, "outfmt",
"{a2m=fa[sta],clu[stal],msf,phy[lip],selex,st[ockholm],vie[nna]}",
"MSA output file format (default: fasta)");
struct arg_int *opt_wrap = arg_int0(NULL, "wrap", "<n>",
"number of residues before line-wrap in output");
struct arg_str *opt_output_order = arg_str0(NULL, "output-order",
"{input-order,tree-order}",
"MSA output orderlike in input/guide-tree");
struct arg_rem *rem_iteration = arg_rem(NULL, "\nIteration:");
struct arg_str *opt_num_iterations = arg_str0(NULL, "iterations,iter",
/* FIXME "{<n>,auto}", "Number of combined guide-tree/HMM iterations"); */
"<n>", "Number of (combined guide-tree/HMM) iterations");
struct arg_int *opt_max_guidetree_iterations = arg_int0(NULL, "max-guidetree-iterations",
"<n>", "Maximum number guidetree iterations");
struct arg_int *opt_max_hmm_iterations = arg_int0(NULL, "max-hmm-iterations",
"<n>", "Maximum number of HMM iterations");
struct arg_rem *rem_limits = arg_rem(NULL, "\nLimits (will exit early, if exceeded):");
struct arg_int *opt_max_seq = arg_int0(NULL, "maxnumseq", "<n>",
"Maximum allowed number of sequences");
struct arg_int *opt_max_seqlen = arg_int0(NULL, "maxseqlen", "<l>",
"Maximum allowed sequence length");
struct arg_rem *rem_misc = arg_rem(NULL, "\nMiscellaneous:");
struct arg_lit *opt_autooptions = arg_lit0(NULL, "auto",
"Set options automatically (might overwrite some of your options)");
struct arg_int *opt_threads = arg_int0(NULL, "threads", "<n>",
"Number of processors to use");
struct arg_file *opt_logfile = arg_file0("l", "log",
"<file>",
"Log all non-essential output to this file");
struct arg_lit *opt_help = arg_lit0("h", "help",
"Print this help and exit");
struct arg_lit *opt_version = arg_lit0(NULL, "version",
"Print version information and exit");
struct arg_lit *opt_long_version = arg_lit0(NULL, "long-version",
"Print long version information and exit");
struct arg_lit *opt_verbose = arg_litn("v", "verbose",
0, 3,
"Verbose output (increases if given multiple times)");
struct arg_lit *opt_force = arg_lit0(NULL, "force",
"Force file overwriting");
struct arg_lit *opt_r_seq = arg_lit0(NULL, "R",
"Force sequence from R");
struct arg_int *opt_macram = arg_int0(NULL, "MAC-RAM", "<n>", /* keep this quiet for the moment, FS r240 -> */
NULL/*"maximum amount of RAM to use for MAC algorithm (in MB)"*/);
struct arg_end *opt_end = arg_end(10); /* maximum number of errors
* to store */
void *argtable[] = {rem_seq_input,
opt_seqin,
opt_hmm_in,
opt_dealign,
opt_profile1,
opt_profile2,
opt_isprofile, /* FS, r282 ->*/
opt_seqtype,
/* opt_force_protein, */
opt_infmt,
rem_guidetree,
#if 0
/* no other options then default available or not implemented */
opt_pairdist,
#endif
opt_distmat_in,
opt_distmat_out,
opt_guidetree_in,
opt_guidetree_out,
//added for R
opt_gapopen,
opt_gapext,
//added for R
opt_full, /* FS, r250 -> */
opt_full_iter, /* FS, r250 -> */
opt_clustersize, /* FS, r274 -> */
opt_clustfile, /* FS, r274 -> */
opt_usekimura, /* FS, r282 ->*/
opt_percentid, /* FS, r282 ->*/
#if 0
/* no other options then default available */
opt_clustering,
#endif
rem_aln_output,
opt_outfile,
opt_outfmt,
opt_resno, /* FS, 274 -> */
opt_wrap, /* FS, 274 -> */
opt_output_order, /* FS, 274 -> */
rem_iteration,
opt_num_iterations,
opt_max_guidetree_iterations,
opt_max_hmm_iterations,
rem_limits,
opt_max_seq,
opt_max_seqlen,
rem_misc,
opt_autooptions,
opt_threads,
opt_logfile,
opt_help,
opt_verbose,
opt_version,
opt_long_version,
opt_force,
opt_r_seq,
opt_macram, /* FS, r240 -> r241 */
opt_end};
int nerrors;
/* Verify the argtable[] entries were allocated sucessfully
*/
if (arg_nullcheck(argtable)) {
Log(&rLog, LOG_FATAL, "insufficient memory (for argtable allocation)");
}
/* Parse the command line as defined by argtable[]
*/
nerrors = arg_parse(argc, argv, argtable);
/* Special case: '--help' takes precedence over error reporting
*/
if (opt_help->count > 0) {
printf("%s - %s (%s)\n", PACKAGE_NAME, PACKAGE_VERSION, PACKAGE_CODENAME);
printf("\n");
printf("If you like Clustal-Omega please cite:\n%s\n", CITATION);
printf("If you don't like Clustal-Omega, please let us know why (and cite us anyway).\n");
/* printf("You can contact reach us under %s\n", PACKAGE_BUGREPORT); */
printf("\n");
printf("Check http://www.clustal.org for more information and updates.\n");
printf("\n");
printf("Usage: %s", basename(argv[0]));
arg_print_syntax(stdout,argtable, "\n");
printf("\n");
printf("A typical invocation would be: %s -i my-in-seqs.fa -o my-out-seqs.fa -v\n",
basename(argv[0]));
printf("See below for a list of all options.\n");
arg_print_glossary(stdout, argtable, " %-25s %s\n");
arg_freetable(argtable, sizeof(argtable)/sizeof(argtable[0]));
throw(ClustalOmegaException, "0");
}
/* Special case: '--version' takes precedence over error reporting
*/
if (opt_version->count > 0) {
printf("%s\n", PACKAGE_VERSION);
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
throw(ClustalOmegaException, "0");
}
/* Special case: '--long-version' takes precedence over error reporting
*/
if (opt_long_version->count > 0) {
char zcLongVersion[1024];
PrintLongVersion(zcLongVersion, sizeof(zcLongVersion));
printf("%s\n", zcLongVersion);
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
throw(ClustalOmegaException, "0");
}
/* If the parser returned any errors then display them and exit
*/
if (nerrors > 0) {
/* Display the error details contained in the arg_end struct.*/
arg_print_errors(stdout, opt_end, PACKAGE);
fprintf(stderr, "For more information try: %s --help\n", argv[0]);
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
throw(ClustalOmegaException, "1");
}
/* ------------------------------------------------------------
*
* Command line successfully parsed. Now transfer values to
* user_opts. While doing so, make sure that given input files
* exist and given output files are writable do not exist, or if
* they do, should be overwritten.
*
* No logic checks here! They are done in a different function
*
* ------------------------------------------------------------*/
/* not part of user_opts because it declared in src/util.h */
if (0 == opt_verbose->count) {
rLog.iLogLevelEnabled = LOG_WARN;
} else if (1 == opt_verbose->count) {
rLog.iLogLevelEnabled = LOG_INFO;
} else if (2 == opt_verbose->count) {
rLog.iLogLevelEnabled = LOG_VERBOSE;
} else if (3 == opt_verbose->count) {
rLog.iLogLevelEnabled = LOG_DEBUG;
}
user_opts->aln_opts.bAutoOptions = opt_autooptions->count;
user_opts->bDealignInputSeqs = opt_dealign->count;
/* NOTE: full distance matrix used to be default - there was
--mbed flag but no --full flag after r250 decided that mBed
should be default - now need --full flag to turn off mBed.
wanted to retain mBed Boolean, so simply added --full flag. if
both flags set (erroneously) want --mbed to overwrite --full,
therefore do --full 1st, the --mbed, FS, r250 */
if (opt_full->count){
user_opts->aln_opts.bUseMbed = FALSE;
}
if (opt_full_iter->count){
user_opts->aln_opts.bUseMbedForIteration = FALSE;
}
user_opts->bForceFileOverwrite = opt_force->count;
if (opt_r_seq->count){
user_opts->bRSequence = TRUE;
}
/* log-file
*/
if (opt_logfile->count > 0) {
user_opts->pcLogFile = CkStrdup(opt_logfile->filename[0]);
/* warn if already exists or not writable */
if (FileExists(user_opts->pcLogFile) && ! user_opts->bForceFileOverwrite) {
Log(&rLog, LOG_FATAL, "%s '%s'. %s",
"Cowardly refusing to overwrite already existing file",
user_opts->pcLogFile,
"Use --force to force overwriting.");
}
if (! FileIsWritable(user_opts->pcLogFile)) {
Log(&rLog, LOG_FATAL, "Sorry, I do not have permission to write to file '%s'.",
user_opts->pcLogFile);
}
}
/* normal sequence input (no profile)
*/
if (opt_seqin->count > 0) {
user_opts->pcSeqInfile = CkStrdup(opt_seqin->filename[0]);
}
/* Input limitations
*/
/* maximum number of sequences */
if (opt_max_seq->count > 0) {
user_opts->iMaxNumSeq = opt_max_seq->ival[0];
}
/* maximum sequence length */
if (opt_max_seqlen->count > 0) {
user_opts->iMaxSeqLen = opt_max_seqlen->ival[0];
}
/* Output format
*/
if (opt_infmt->count > 0) {
/* avoid gcc warning about discarded qualifier */
char *tmp = (char *)opt_infmt->sval[0];
user_opts->iSeqInFormat = String2SeqfileFormat(tmp);
} else {
user_opts->iSeqInFormat = SQFILE_UNKNOWN;
}
/* Sequence type
*/
if (opt_seqtype->count > 0) {
if (STR_NC_EQ(opt_seqtype->sval[0], "protein")) {
user_opts->iSeqType = SEQTYPE_PROTEIN;
} else if (STR_NC_EQ(opt_seqtype->sval[0], "rna")) {
user_opts->iSeqType = SEQTYPE_RNA;
} else if (STR_NC_EQ(opt_seqtype->sval[0], "dna")) {
user_opts->iSeqType = SEQTYPE_DNA;
} else {
Log(&rLog, LOG_FATAL, "Unknown sequence type '%s'", opt_seqtype->sval[0]);
}
}
/* if (opt_force_protein->count > 0) {
user_opts->iSeqType = SEQTYPE_PROTEIN;
} */
/* Profile input
*/
if (opt_profile1->count > 0) {
user_opts->pcProfile1Infile = CkStrdup(opt_profile1->filename[0]);
if (! FileExists(user_opts->pcProfile1Infile)) {
Log(&rLog, LOG_FATAL, "File '%s' does not exist.", user_opts->pcProfile1Infile);
}
}
if (opt_profile2->count > 0) {
user_opts->pcProfile2Infile = CkStrdup(opt_profile2->filename[0]);
if (! FileExists(user_opts->pcProfile2Infile)) {
Log(&rLog, LOG_FATAL, "File '%s' does not exist.", user_opts->pcProfile2Infile);
}
}
if (opt_isprofile->count){
user_opts->bIsProfile = TRUE;
}
if (opt_usekimura->count){
user_opts->aln_opts.bUseKimura = TRUE;
}
if (opt_percentid->count){
user_opts->aln_opts.bPercID = TRUE;
}
/* HMM input
*/
user_opts->aln_opts.iHMMInputFiles = 0;
user_opts->aln_opts.ppcHMMInput = NULL;
if (opt_hmm_in->count>0) {
int iAux;
user_opts->aln_opts.iHMMInputFiles = opt_hmm_in->count;
user_opts->aln_opts.ppcHMMInput = (char **) CKMALLOC(
user_opts->aln_opts.iHMMInputFiles * sizeof(char*));
for (iAux=0; iAux<opt_hmm_in->count; iAux++) {
user_opts->aln_opts.ppcHMMInput[iAux] = CkStrdup(opt_hmm_in->filename[iAux]);
if (! FileExists(user_opts->aln_opts.ppcHMMInput[iAux])) {
Log(&rLog, LOG_FATAL, "File '%s' does not exist.", user_opts->aln_opts.ppcHMMInput[iAux]);
}
}
}
/* Pair distance method
*/
if (opt_pairdist->count > 0) {
if (STR_NC_EQ(opt_pairdist->sval[0], "ktuple")) {
user_opts->aln_opts.iPairDistType = PAIRDIST_KTUPLE;
} else {
Log(&rLog, LOG_FATAL, "Unknown pairdist method '%s'", opt_pairdist->sval[0]);
}
}
#if !0
free(opt_pairdist);
#endif
/* Distance matrix input
*/
if (opt_distmat_in->count > 0) {
user_opts->aln_opts.pcDistmatInfile = CkStrdup(opt_distmat_in->filename[0]);
if (! FileExists(user_opts->aln_opts.pcDistmatInfile)) {
Log(&rLog, LOG_FATAL, "File '%s' does not exist.", user_opts->aln_opts.pcDistmatInfile);
}
}
/* Distance matrix output
*/
if (opt_distmat_out->count > 0) {
user_opts->aln_opts.pcDistmatOutfile = CkStrdup(opt_distmat_out->filename[0]);
/* warn if already exists or not writable */
if (FileExists(user_opts->aln_opts.pcDistmatOutfile) && ! user_opts->bForceFileOverwrite) {
Log(&rLog, LOG_FATAL, "%s '%s'. %s",
"Cowardly refusing to overwrite already existing file",
user_opts->aln_opts.pcDistmatOutfile,
"Use --force to force overwriting.");
}
if (! FileIsWritable(user_opts->aln_opts.pcDistmatOutfile)) {
Log(&rLog, LOG_FATAL, "Sorry, I do not have permission to write to file '%s'.",
user_opts->aln_opts.pcDistmatOutfile);
}
}
/* Clustering
*
*/
if (opt_clustering->count > 0) {
if (STR_NC_EQ(opt_clustering->sval[0], "upgma")) {
user_opts->aln_opts.iClusteringType = CLUSTERING_UPGMA;
} else {
Log(&rLog, LOG_FATAL, "Unknown guide-tree clustering method '%s'", opt_clustering->sval[0]);
}
}
#if !0
free(opt_clustering);
#endif
if (opt_clustersize->count > 0){ /* FS, r274 -> */
if (opt_clustersize->ival[0] > 0){
user_opts->aln_opts.iClustersizes = opt_clustersize->ival[0];
}
}
if (opt_clustfile->count > 0){ /* FS, r274 -> */
user_opts->aln_opts.pcClustfile = CkStrdup(opt_clustfile->filename[0]);
/*if (! FileExists(user_opts->aln_opts.pcClustfile)) {
Log(&rLog, LOG_FATAL, "File '%s' does not exist.", user_opts->aln_opts.pcClustfile);
}*/
}
/* Guidetree input
*/
if (opt_guidetree_in->count > 0) {
user_opts->aln_opts.pcGuidetreeInfile = CkStrdup(opt_guidetree_in->filename[0]);
if (! FileExists(user_opts->aln_opts.pcGuidetreeInfile)) {
Log(&rLog, LOG_FATAL, "File '%s' does not exist.", user_opts->aln_opts.pcGuidetreeInfile);
}
}
/* Guidetree output
*/
if (opt_guidetree_out->count > 0) {
user_opts->aln_opts.pcGuidetreeOutfile = CkStrdup(opt_guidetree_out->filename[0]);
/* warn if already exists or not writable */
if (FileExists(user_opts->aln_opts.pcGuidetreeOutfile) && ! user_opts->bForceFileOverwrite) {
Log(&rLog, LOG_FATAL, "%s '%s'. %s",
"Cowardly refusing to overwrite already existing file",
user_opts->aln_opts.pcGuidetreeOutfile,
"Use --force to force overwriting.");
}
if (! FileIsWritable(user_opts->aln_opts.pcGuidetreeOutfile)) {
Log(&rLog, LOG_FATAL, "Sorry, I do not have permission to write to file '%s'.",
user_opts->aln_opts.pcGuidetreeOutfile);
}
}
/* max guidetree iterations
*/
if (opt_max_guidetree_iterations->count > 0) {
user_opts->aln_opts.iMaxGuidetreeIterations = opt_max_guidetree_iterations->ival[0];
}
/* max guidetree iterations
*/
if (opt_max_hmm_iterations->count > 0) {
user_opts->aln_opts.iMaxHMMIterations = opt_max_hmm_iterations->ival[0];
}
/* number of iterations
*/
if (opt_num_iterations->count > 0) {
if (STR_NC_EQ(opt_num_iterations->sval[0], "auto")) {
Log(&rLog, LOG_FATAL, "Automatic iteration not supported at the moment.");
user_opts->aln_opts.bIterationsAuto = TRUE;
} else {
int iAux;
user_opts->aln_opts.bIterationsAuto = FALSE;
for (iAux=0; iAux<(int)strlen(opt_num_iterations->sval[0]); iAux++) {
if (! isdigit(opt_num_iterations->sval[0][iAux])) {
Log(&rLog, LOG_FATAL, "Couldn't iteration parameter: %s",
opt_num_iterations->sval[0]);
}
}
user_opts->aln_opts.iNumIterations = atoi(opt_num_iterations->sval[0]);
}
}
/* Alignment output
*/
if (opt_outfile->count > 0) {
user_opts->pcAlnOutfile = CkStrdup(opt_outfile->filename[0]);
/* warn if already exists or not writable */
if (FileExists(user_opts->pcAlnOutfile) && ! user_opts->bForceFileOverwrite) {
Log(&rLog, LOG_FATAL, "%s '%s'. %s",
"Cowardly refusing to overwrite already existing file",
user_opts->pcAlnOutfile,
"Use --force to force overwriting.");
}
if (! FileIsWritable(user_opts->pcAlnOutfile)) {
Log(&rLog, LOG_FATAL, "Sorry, I do not have permission to write to file '%s'.",
user_opts->pcAlnOutfile);
}
}
/* Output format
*/
if (opt_outfmt->count > 0) {
/* avoid gcc warning about discarded qualifier */
char *tmp = (char *)opt_outfmt->sval[0];
user_opts->iAlnOutFormat = String2SeqfileFormat(tmp);
if (SQFILE_UNKNOWN == user_opts->iAlnOutFormat) {
Log(&rLog, LOG_FATAL, "Unknown output format '%s'", opt_outfmt->sval[0]);
}
}
/* Number of threads
*/
#ifdef HAVE_OPENMP
if (opt_threads->count > 0) {
if (opt_threads->ival[0] <= 0) {
Log(&rLog, LOG_FATAL, "Changing number of threads to %d doesn't make sense.",
opt_threads->ival[0]);
}
user_opts->iThreads = opt_threads->ival[0];
}
#else
if (opt_threads->count > 0) {
if (opt_threads->ival[0] > 1) {
Log(&rLog, LOG_FATAL, "Cannot change number of threads to %d. %s was build without OpenMP support.",
opt_threads->ival[0], PACKAGE_NAME);
}
}
#endif
if (opt_gapopen->count > 0) {
user_opts->aln_opts.rHhalignPara.gapOpening = (float)opt_gapopen->dval[0];
}
if (opt_gapext->count > 0) {
user_opts->aln_opts.rHhalignPara.gapExtension = (float)opt_gapext->dval[0];
}
/* max MAC RAM (maximum amount of RAM set aside for MAC algorithm)
*/
if (opt_macram->count > 0) { /* FS, r240 -> r241 */
user_opts->aln_opts.rHhalignPara.iMacRamMB = opt_macram->ival[0];
}
/* Number of residues in output before line-wrap
*/
if (opt_wrap->count > 0) { /* FS, r274 -> */
user_opts->iWrap = opt_wrap->ival[0];
}
user_opts->bResno = opt_resno->count;
/* output-order
* like input (INPUT_ORDER = 0) or tree (TREE_ORDER = 1)
* if output-order format not valid use INPUT_ORDER
*/
if (opt_output_order->count > 0){
user_opts->iOutputOrder = (0 == strcmp(opt_output_order->sval[0], "input-order")) ? INPUT_ORDER :
(0 == strcmp(opt_output_order->sval[0], "tree-order")) ? TREE_ORDER : INPUT_ORDER;
}
arg_freetable(argtable,sizeof(argtable)/sizeof(argtable[0]));
UserOptsLogicCheck(user_opts);
return;
}
/* end of ParseCommandLine() */
/**
*
* @brief the 'real' main function
*
*/
int
executeClustalOmega(int argc, char **argv, ClustalOmegaInput *msaInput, ClustalOmegaOutput *msaOutput)
{
mseq_t *prMSeq = NULL;
mseq_t *prMSeqProfile1 = NULL;
mseq_t *prMSeqProfile2 = NULL;
cmdline_opts_t cmdline_opts;
/* Must happen first: setup logger */
LogDefaultSetup(&rLog);
/*Log(&rLog, LOG_WARN, "This is a non-public realase of %s. Please do not distribute.", PACKAGE_NAME);*/
/*Log(&rLog, LOG_WARN, "This is a beta version of %s, for protein only.", PACKAGE_NAME);*/ /* FS, r237 -> 238 */
SetDefaultUserOpts(&(cmdline_opts));
ParseCommandLine(&cmdline_opts, argc, argv);
if (NULL != cmdline_opts.pcLogFile) {
prLogFile = fopen(cmdline_opts.pcLogFile, "w");
LogSetFP(&rLog, LOG_INFO, prLogFile);
LogSetFP(&rLog, LOG_VERBOSE, prLogFile);
LogSetFP(&rLog, LOG_DEBUG, prLogFile);
}
InitClustalOmega(cmdline_opts.iThreads);
if (rLog.iLogLevelEnabled < LOG_INFO) {
PrintUserOpts(LogGetFP(&rLog, LOG_INFO), & cmdline_opts);
PrintAlnOpts(LogGetFP(&rLog, LOG_INFO), & (cmdline_opts.aln_opts));
}
/* Read sequence file
*
*/
if (NULL != cmdline_opts.pcSeqInfile || cmdline_opts.bRSequence) {
NewMSeq(&prMSeq);
if (!cmdline_opts.bRSequence) {
Log(&rLog, LOG_INFO, "Reading sequence file from '%s'", cmdline_opts.pcSeqInfile);
if (ReadSequences(prMSeq, cmdline_opts.pcSeqInfile,
cmdline_opts.iSeqType, cmdline_opts.iSeqInFormat,
cmdline_opts.bIsProfile,
cmdline_opts.iMaxNumSeq, cmdline_opts.iMaxSeqLen)) {
Log(&rLog, LOG_FATAL, "Reading sequence file '%s' failed", cmdline_opts.pcSeqInfile);
}
} else {
Log(&rLog, LOG_INFO, "Reading sequence file from R");
if (ReadSequencesFromR(prMSeq, msaInput->seqLength, msaInput->inputSeqs, msaInput->seqNames,
cmdline_opts.iSeqType, cmdline_opts.iSeqInFormat,
cmdline_opts.bIsProfile,
cmdline_opts.iMaxNumSeq, cmdline_opts.iMaxSeqLen)) {
Log(&rLog, LOG_FATAL, "Reading sequence file '%s' failed", cmdline_opts.pcSeqInfile);
}
}
#if TRACE
{
int iAux;
for (iAux=0; iAux<prMSeq->nseqs; iAux++) {
Log(&rLog, LOG_FORCED_DEBUG, "seq no %d: seq = %s", iAux, prMSeq->seq[iAux]);
LogSqInfo(&prMSeq->sqinfo[iAux]);
}
}
#endif
}
/* k-tuple pairwise distance calculation seg-faults if
* only one sequence, simply exit early.
* note that for profile/profile alignment prMSeq is NULL
* FS, r222->r223 */
if (prMSeq && (prMSeq->nseqs <= 1)){
Log(&rLog, LOG_FATAL, "File '%s' contains %d sequence%s, nothing to align",
cmdline_opts.pcSeqInfile, prMSeq->nseqs, 1==prMSeq->nseqs?"":"s");
}
/* if there are fewer sequences than target size of clusters,
* then mBed is unnecessary, FS, r283-> */
if ( (prMSeq) && (prMSeq->nseqs <= cmdline_opts.aln_opts.iClustersizes) ){
cmdline_opts.aln_opts.bUseMbed = FALSE;
cmdline_opts.aln_opts.bUseMbedForIteration = FALSE;
Log(&rLog, LOG_INFO, "not more sequences (%d) than cluster-size (%d), turn off mBed",
prMSeq->nseqs, cmdline_opts.aln_opts.iClustersizes);
}
/* Dealign if requested and neccessary
*/
if (NULL != prMSeq) {
if (TRUE == prMSeq->aligned && cmdline_opts.bDealignInputSeqs) {
Log(&rLog, LOG_INFO, "Dealigning already aligned input sequences as requested.");
DealignMSeq(prMSeq);
}
}
/* Read profile1
*
*/
if (NULL != cmdline_opts.pcProfile1Infile) {
NewMSeq(&prMSeqProfile1);
if (ReadSequences(prMSeqProfile1, cmdline_opts.pcProfile1Infile,
cmdline_opts.iSeqType, cmdline_opts.iSeqInFormat,
cmdline_opts.bIsProfile,
cmdline_opts.iMaxNumSeq, cmdline_opts.iMaxSeqLen)) {
Log(&rLog, LOG_FATAL, "Reading sequences from profile file '%s' failed",
cmdline_opts.pcProfile1Infile);
}
/* FIXME: commented out. FS, r240 -> r241
* for explanation see below */
/*if (1==prMSeqProfile1->nseqs) {
Log(&rLog, LOG_FATAL, "'%s' contains only one sequence and can therefore not be used as a profile",
cmdline_opts.pcProfile1Infile);
}*/
if (FALSE == prMSeqProfile1->aligned) {
Log(&rLog, LOG_FATAL, "Sequences in '%s' are not aligned, i.e. this is not a profile",
cmdline_opts.pcProfile1Infile);
}
}
/* Read profile2
*
*/
if (NULL != cmdline_opts.pcProfile2Infile) {
NewMSeq(&prMSeqProfile2);
if (ReadSequences(prMSeqProfile2, cmdline_opts.pcProfile2Infile,
cmdline_opts.iSeqType, cmdline_opts.iSeqInFormat,
cmdline_opts.bIsProfile,
cmdline_opts.iMaxNumSeq, cmdline_opts.iMaxSeqLen)) {
Log(&rLog, LOG_FATAL, "Reading sequences from profile file '%s' failed",
cmdline_opts.pcProfile2Infile);
}
/* FIXME: there is no (clean) way to align a single sequence to a profile.
* if we go down the -i route, it causes a seg-fault in the pair-wise
* k-tuple distance calculation. However, single sequences can be
* understood as 1-profiles. Therefore we have to allow for 1-profiles.
* FS, r240 -> r241
*/
/*if (1==prMSeqProfile2->nseqs) {
Log(&rLog, LOG_FATAL, "'%s' contains only one sequence and can therefore not be used as a profile",
cmdline_opts.pcProfile2Infile);
}*/
if (FALSE == prMSeqProfile2->aligned) {
Log(&rLog, LOG_FATAL, "Sequences in '%s' are not aligned, i.e. this is not a profile",
cmdline_opts.pcProfile2Infile);
}
}
/* Depending on the input we got perform
*
* (i) normal alignment: seq + optional profile
* or
* (ii) profile profile alignment
*
*/
cmdline_opts.aln_opts.rHhalignPara.substitutionMatrix = msaInput->substitutionMatrix;
if (NULL != prMSeq) {
if (2 == prMSeq->nseqs){
/* if there are only 2 sequences then the order does not matter */
/* this is important, because for pair-wise alignment we don't do
* tree indexing*, and trying to use tree-indexing during output
* will cause a segmentation fault */
cmdline_opts.iOutputOrder = INPUT_ORDER;
}
if (TREE_ORDER == cmdline_opts.iOutputOrder){
/* this is a crutch, if tree_order==NULL use input order,
* otherwise use guide-tree-order */
prMSeq->tree_order = (int *)CKMALLOC(prMSeq->nseqs * sizeof(int));
}
if (Align(prMSeq, prMSeqProfile1, & cmdline_opts.aln_opts)) {
Log(&rLog, LOG_FATAL, "An error occured during the alignment");
}
if (cmdline_opts.aln_opts.iMaxHMMIterations >= 0){
if (WriteAlignment(prMSeq, cmdline_opts.pcAlnOutfile,
cmdline_opts.iAlnOutFormat, cmdline_opts.iWrap, cmdline_opts.bResno,
&msaOutput->msa_c, &msaOutput->msa_v)) {
Log(&rLog, LOG_FATAL, "Could not save alignment to %s", cmdline_opts.pcAlnOutfile);
}
}
#if 0
{
bool bSampling = FALSE; /* better set to TRUE for many sequences */
bool bReportAll = TRUE;
AliStat(prMSeq, bSampling, bReportAll);
}
#endif
} else if (NULL != prMSeqProfile1 && NULL != prMSeqProfile2) {
if (AlignProfiles(prMSeqProfile1, prMSeqProfile2,
cmdline_opts.aln_opts.rHhalignPara)) {
Log(&rLog, LOG_FATAL, "An error occured during the alignment");
}
if (WriteAlignment(prMSeqProfile1, cmdline_opts.pcAlnOutfile,
cmdline_opts.iAlnOutFormat, cmdline_opts.iWrap, cmdline_opts.bResno,
&msaOutput->msa_c, &msaOutput->msa_v)) {
Log(&rLog, LOG_FATAL, "Could not save alignment to %s", cmdline_opts.pcAlnOutfile);
}
}
/* cleanup
*/
if (NULL != prMSeq) {
FreeRSeq(&prMSeq, cmdline_opts.bRSequence);
}
if (NULL != prMSeqProfile1) {
FreeMSeq(&prMSeqProfile1);
}
if (NULL != prMSeqProfile2) {
FreeMSeq(&prMSeqProfile2);
}
FreeUserOpts(&cmdline_opts);
Log(&rLog, LOG_DEBUG, "Successful program exit");
if (NULL != cmdline_opts.pcLogFile) {
fclose(prLogFile);
}
free(prMSeq);
return EXIT_SUCCESS;
}
/* end of MyMain() */
|
