This file is indexed.

/usr/include/clustalo/clustal-omega.h is in libclustalo-dev 1.2.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
/* -*- 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: clustal-omega.h 212 2011-03-10 15:09:46Z andreas $
 */

#ifndef CLUSTALO_H
#define CLUSTALO_H



#ifdef HAVE_OPENMP
#include <omp.h>
#endif
#include <stdbool.h>

#include "clustal-omega-config.h"

/* the following needs to be kept in sync with library_include_HEADERS of all
 * subdir Makefile.am's 
 */

/* hhalign */
#include "hhalign/general.h"
#include "hhalign/hhfunc.h"


/* clustal */
#include "clustal/log.h"
#include "clustal/util.h"
#include "clustal/symmatrix.h"
#include "clustal/tree.h"
#include "clustal/seq.h"
#include "clustal/mbed.h"
#include "clustal/weights.h"
#include "clustal/pair_dist.h"
#include "clustal/hhalign_wrapper.h"



#define CLUSTERING_UNKNOWN 0
#define CLUSTERING_UPGMA 1

/* weights will be computed if 1. but are not really used for now and they
 * might slow things down. also, mbed's screws up branch lengths which will
 * have a negative effect on weights 
*/
#define USE_WEIGHTS 0

extern int iNumberOfThreads;

/* output order */
enum {INPUT_ORDER = 0, TREE_ORDER};


/** user/commandline options
 *
 * changes here will have to be reflected in ParseCommandLine()
 * and during setup of the default opts
 *
 */
typedef struct {
    /* auto: Clustal (know what) is good for you
     */
    bool bAutoOptions;

    /* Distance matrix
     */
    /** distance matrix input file */
    char *pcDistmatInfile;
    /** distance matrix output file */
    char *pcDistmatOutfile;
    
    /* Clustering / guide-tree
     */
    /** clustering type (from cmdline arg) */
    int iClusteringType;
    /** number of sequences in cluster */
    int iClustersizes; 
    /** file with clustering information */
    char *pcClustfile; 
    /** use transitivity */
    int iTransitivity; 
    /** file with posterior probability information */
    char *pcPosteriorfile; 
    /** pairwise distance method */
    int iPairDistType;
    /** use mbed-like clustering */
    bool bUseMbed;
    /** use mbed-like clustering also during iteration */
    bool bUseMbedForIteration;
    /** pile-up flag */
    bool bPileup;
    /** guidetree output file */
    char *pcGuidetreeOutfile;
    /** guidetree input file */
    char *pcGuidetreeInfile;
    /** use Kimura corrected distance */
    bool bUseKimura;
    /** print percentage identity */
    bool bPercID;

    /* HMMs
     */
    /** HMM input files. index range: 0..iHMMInputFiles */
    char **ppcHMMInput;
    /** number of provided HMM input files. not really a user
       option but need for ppcHMMInput */
    int iHMMInputFiles;

    /* Iteration
     */
    /** number of iterations */
    int iNumIterations;
    /** determine number of iterations automatically */
	bool bIterationsAuto;
    /** maximum number of hmm iterations */
    int iMaxHMMIterations;
    /** max number of guidetree iterations */
	int iMaxGuidetreeIterations;
    
    hhalign_para rHhalignPara;

    /* changes here will have to be reflected in FreeAlnOpts(),
	 * SetDefaultAlnOpts(), AlnOptsLogicCheck() etc 
	 */
} opts_t;



extern void 
PrintLongVersion(char *pcStr, int iSize);

extern void
SetDefaultAlnOpts(opts_t *opts);

extern void
FreeAlnOpts(opts_t *aln_opts);

extern void
AlnOptsLogicCheck(opts_t *opts);

extern void
PrintAlnOpts(FILE *prFile, opts_t *opts);

extern void
InitClustalOmega(int iNumThreadsToUse);

extern void
SequentialAlignmentOrder(int **piOrderLR_p, int iNumSeq);

extern int
AlignmentOrder(int **piOrderLR_p, double **pdSeqWeights_p, mseq_t *prMSeq,
               int iPairDistType, char *pcDistmatInfile, char *pcDistmatOutfile,
               int iClusteringType, int iClustersizes,
               char *pcGuidetreeInfile, char *pcGuidetreeOutfile, char *pcClusterFile,
               bool bUseMBed, bool bPercID);

extern int
Align(mseq_t *prMSeq, 
      mseq_t *prMSeqProfile,
	  opts_t *prOpts);

extern int
AlignProfiles(mseq_t *prMSeqProfile1, 
			  mseq_t *prMSeqProfile2, hhalign_para rHhalignPara);

#endif
extern int
ReadPseudoCountParams(hhalign_para *rHhalignPara_p, char *pcPseudoFile);