B.3 msaClustalOmega
B.3.3 Flag Options
Parameter Default Default Activated Comments
Value Type R RCPP C++/C inmsa
auto FALSE Bool
X X X X
dealign FALSE Bool
X X X X
force FALSE Bool
X X X X
full FALSE Bool
X X X X
fullIter FALSE Bool
X X X X
isProfile FALSE Bool
X X X X
longVersion FALSE Bool
X X X X
percentId FALSE Bool
X X X X
residueNumber FALSE Bool
X X X X
useKimura FALSE Bool
X X X X
version FALSE Bool
X X X X
Code Changes C
C.1 MUSCLE
C.1.1 ../msa/src/Muscle/aligngivenpath.cpp
391 - 391: };
392 - 392:
393 - 393: // MM
394 : // Ai<96>1 Ai Out 394: // Ai 1 Ai Out 395 - 395: // X X LL LL 396 - 396: // X - LG LG 397 - 397: // - X GL GL 398 - 398: // - - GG GG 399 - 399: //
400 : // Bj<96>1 Bj 400: // Bj 1 Bj
401 - 401: // X X LL LL 402 - 402: // X - LG LG 403 - 403: // - X GL GL 418 - 418: }
419 - 419:
420 - 420: // MD
421 : // Ai<96>1 Ai Out 421: // Ai 1 Ai Out 422 - 422: // X X LL LL 423 - 423: // X - LG LG 424 - 424: // - X GL GL 443 - 443: }
444 - 444:
445 - 445: // DD
446 : // Ai<96>1 Ai Out 446: // Ai 1 Ai Out 447 - 447: // X X LL LL 448 - 448: // X - LG LG 449 - 449: // - X GL GL 470 - 470: // X - ?L LG 471 - 471: // - - ?G GG 472 - 472:
473 : // Bj<96>1 Bj 473: // Bj 1 Bj
474 - 474: // X X LL LL 475 - 475: // X - LG LG 476 - 476: // - X GL GL 491 - 491: }
492 - 492:
493 - 493: // DM
494 : // Ai<96>1 Ai Out 494: // Ai 1 Ai Out
495 - 495: // X X LL LL 496 - 496: // X - LG LG 497 - 497: // - X GL GL 520 - 520: // - X ?L GL 521 - 521: // - - ?G GG 522 - 522:
523 : // Bj<96>1 Bj 523: // Bj 1 Bj
524 - 524: // X X LL LL 525 - 525: // X - LG LG 526 - 526: // - X GL GL 590 - 590: // (-) (-) Out 591 - 591: // - - ?? GG 592 - 592:
593 : // Bj<96>1 Bj 593: // Bj 1 Bj
594 - 594: // X X LL LL 595 - 595: // X - LG LG 596 - 596: // - X GL GL
C.1.2 ../msa/src/Muscle/aln.cpp
3 - 3: #include <ctype.h>
4 - 4: #include "msa.h"
5 - 5: #include "textfile.h"
6: #include <vector>
7: #include <string>
8: #include <sstream>
9: using namespace std;
6 - 10:
7 - 11: const unsigned uCharsPerLine = 60;
8 - 12: const int MIN_NAME = 10;
87 - 91: } 88 - 92: } 89 - 93:
94: vector<string> MSA::ToAlnFile() const
95: {
96:
97: string line = "";
98: vector<string> result;
99: line = string(MUSCLE_LONG_VERSION) + string(" - multiple sequence alignment");
100: result.push_back(line);
101: line = "";
102: result.push_back("");
103:
104: result.push_back("");
105:
106: int iLongestNameLength = 0;
107: for (unsigned uSeqIndex = 0; uSeqIndex < GetSeqCount(); ++uSeqIndex)
108: {
109: const char *ptrName = GetSeqName(uSeqIndex);
110: const char *ptrBlank = strchr(ptrName, ’ ’);
111: int iLength;
112: if (0 != ptrBlank)
113: iLength = (int) (ptrBlank - ptrName);
114: else
115: iLength = (int) strlen(ptrName);
116: if (iLength > iLongestNameLength) 117: iLongestNameLength = iLength;
118: }
119: if (iLongestNameLength > MAX_NAME) 120: iLongestNameLength = MAX_NAME;
121: if (iLongestNameLength < MIN_NAME) 122: iLongestNameLength = MIN_NAME;
123:
124: unsigned uLineCount = (GetColCount() - 1)/uCharsPerLine + 1;
125: for (unsigned uLineIndex = 0; uLineIndex < uLineCount; ++uLineIndex)
126: {
127: result.push_back("");
128: unsigned uStartColIndex = uLineIndex*uCharsPerLine;
129: unsigned uEndColIndex = uStartColIndex + uCharsPerLine - 1;
130: if (uEndColIndex >= GetColCount()) 131: uEndColIndex = GetColCount() - 1;
132: char Name[MAX_NAME+1];
133: for (unsigned uSeqIndex = 0; uSeqIndex < GetSeqCount(); ++uSeqIndex)
134: {
135: const char *ptrName = GetSeqName(uSeqIndex);
136: const char *ptrBlank = strchr(ptrName, ’ ’);
137: int iLength;
138: if (0 != ptrBlank)
C.1 MUSCLE
139: iLength = (int) (ptrBlank - ptrName);
140: else
141: iLength = (int) strlen(ptrName);
142: if (iLength > MAX_NAME)
143: iLength = MAX_NAME;
144: memset(Name, ’ ’, MAX_NAME);
145: memcpy(Name, ptrName, iLength);
146: Name[iLongestNameLength] = 0;
147:
148: line = string(Name) + string(" ");
149: for (unsigned uColIndex = uStartColIndex; uColIndex <= uEndColIndex;
150: ++uColIndex)
151: {
152: const char c = GetChar(uSeqIndex, uColIndex);
153: line.append(1, toupper(c));
154: }
155: result.push_back(line);
156: }
157:
158: memset(Name, ’ ’, MAX_NAME);
159: Name[iLongestNameLength] = 0;
160:
161: line = string(Name) + string(" ");
162: for (unsigned uColIndex = uStartColIndex; uColIndex <= uEndColIndex;
163: ++uColIndex)
164: {
165: const char c = GetAlnConsensusChar(*this, uColIndex);
166: line.append(1, c);
167: }
168: result.push_back(line);
169: }
170: return result;
171: } 172:
90 - 173: static char GetAlnConsensusChar(const MSA &a, unsigned uColIndex) 91 - 174: {
92 - 175: const unsigned uSeqCount = a.GetSeqCount();
C.1.3 ../msa/src/Muscle/aln.cpp
96 - 96:
97 - 97: string line = "";
98 - 98: vector<string> result;
99 : line = string(MUSCLE_LONG_VERSION) + string(" - multiple sequence alignment");
99: line = string(MUSCLE_LONG_VERSION) + string(" ");
100 - 100: result.push_back(line);
101 - 101: line = "";
102 - 102: result.push_back("");
C.1.4 ../msa/src/Muscle/diaglist.h
28 - 28: }
29 - 29: ˜DiagList() 30 - 30: {
31 : Free();
31: FreeAll();
32 - 32: } 33 - 33:
34 - 34: public:
35 - 35: // Creation 36 - 36: void Clear() 37 - 37: {
38 : Free();
38: FreeAll();
39 - 39: }
40 - 40: void FromPath(const PWPath &Path);
41 - 41: void Add(const Diag &d);
63 - 63: void LogMe() const;
64 - 64:
65 - 65: private:
66 : void Free() 66: void FreeAll() 67 - 67: {
68 - 68: m_uCount = 0;
69 - 69: }
C.1.5 ../msa/src/Muscle/domuscle.cpp
1 : #include "muscle.h"
1: #include "RMuscle.h"
2: //#include "muscle.h"
2 - 3: #include "textfile.h"
3 : #include "seqvect.h"
4: //#include "seqvect.h"
4 - 5: #include "distfunc.h"
5 - 6: #include "msa.h"
6 - 7: #include "tree.h"
7 - 8: #include "profile.h"
8 - 9: #include "timing.h"
10: #include <vector>
11: #include <string>
12: using namespace std;
9 - 13:
10 - 14: static char g_strUseTreeWarning[] = 11 - 15: "\n******** WARNING ****************\n"
15 - 19: "please refer to the user guide. To disable this\n"
16 - 20: "warning, use -usetree_nowarn <treefilename>.\n\n";
17 - 21:
18 : void DoMuscle()
22: void DoMuscle(MSAInput *msaInput, MSAOutput *msaOutput) 19 - 23: {
20 - 24: SetOutputFileName(g_pstrOutFileName);
21 - 25: SetInputFileName(g_pstrInFileName);
23 - 27: SetMaxIters(g_uMaxIters);
24 - 28: SetSeqWeightMethod(g_SeqWeight1);
25 - 29:
26 : TextFile fileIn(g_pstrInFileName);
27 : SeqVect v;
28 : v.FromFASTAFile(fileIn);
29 : const unsigned uSeqCount = v.Length();
30: if (msaInput->inputSeqs.Length() == 0) { 31: TextFile fileIn(g_pstrInFileName);
32: msaInput->inputSeqs.FromFASTAFile(fileIn);
33: }
30 - 34:
35: const unsigned uSeqCount = msaInput->inputSeqs.Length();
36:
31 - 37: if (0 == uSeqCount)
32 - 38: Quit("No sequences in input file");
33 - 39:
35 - 41: switch (g_SeqType) 36 - 42: {
37 - 43: case SEQTYPE_Auto:
38 : Alpha = v.GuessAlpha();
44: Alpha = msaInput->inputSeqs.GuessAlpha();
39 - 45: break;
40 - 46:
41 - 47: case SEQTYPE_Protein:
54 - 60: Quit("Invalid seq type");
55 - 61: }
56 - 62: SetAlpha(Alpha);
57 : v.FixAlpha();
63: msaInput->inputSeqs.FixAlpha();
58 - 64:
59 - 65: PTR_SCOREMATRIX UserMatrix = 0;
60 - 66: if (0 != g_pstrMatrixFileName) 72 - 78: UserMatrix = ReadMx(File);
73 - 79: g_Alpha = ALPHA_Amino;
74 - 80: g_PPScore = PPSCORE_SP;
75 : }
81: } else if (msaInput->hasSubstitutionMatrix) {
82: UserMatrix = ReadMxFromR(msaInput->colNames, msaInput->substitutionMatrix);
83: g_Alpha = ALPHA_Amino;
84: g_PPScore = PPSCORE_SP;
85: }
76 - 86:
77 - 87: SetPPScore();
78 - 88:
83 - 93: unsigned uTotL = 0;
84 - 94: for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) 85 - 95: {
86 : unsigned L = v.GetSeq(uSeqIndex).Length();
96: unsigned L = msaInput->inputSeqs.GetSeq(uSeqIndex).Length();
87 - 97: uTotL += L;
88 - 98: if (L > uMaxL) 89 - 99: uMaxL = L;
100 - 110: // Initialize sequence ids.
101 - 111: // From this point on, ids must somehow propogate from here.
102 - 112: for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) 103 : v.SetSeqId(uSeqIndex, uSeqIndex);
113: msaInput->inputSeqs.SetSeqId(uSeqIndex, uSeqIndex);
104 - 114:
105 - 115: if (0 == uSeqCount)
106 - 116: Quit("Input file ’%s’ has no sequences", g_pstrInFileName);
107 - 117: if (1 == uSeqCount) 108 - 118: {
109 - 119: TextFile fileOut(g_pstrOutFileName, true);
110 : v.ToFile(fileOut);
C.1 MUSCLE
120: msaInput->inputSeqs.ToFile(fileOut);
111 - 121: return;
112 - 122: } 113 - 123:
114 - 124: if (uSeqCount > 1)
115 : MHackStart(v);
125: MHackStart(msaInput->inputSeqs);
116 - 126:
117 - 127: // First iteration 118 - 128: Tree GuideTree;
140 - 150: continue;
141 - 151: const char *LeafName = GuideTree.GetLeafName(uNodeIndex);
142 - 152: unsigned uSeqIndex;
143 : bool SeqFound = v.FindName(LeafName, &uSeqIndex);
153: bool SeqFound = msaInput->inputSeqs.FindName(LeafName, &uSeqIndex);
144 - 154: if (!SeqFound)
145 - 155: Quit("Label %s in tree does not match sequences", LeafName);
146 : unsigned uId = v.GetSeqIdFromName(LeafName);
156: unsigned uId = msaInput->inputSeqs.GetSeqIdFromName(LeafName);
147 - 157: GuideTree.SetLeafId(uNodeIndex, uId);
148 - 158: } 149 - 159: } 150 - 160: else
151 : TreeFromSeqVect(v, GuideTree, g_Cluster1, g_Distance1, g_Root1,
161: TreeFromSeqVect(msaInput->inputSeqs, GuideTree, g_Cluster1, g_Distance1, g_Root1,
152 - 162: g_pstrDistMxFileName1);
153 - 163:
154 - 164: const char *Tree1 = ValueOpt("Tree1");
157 - 167: TextFile f(Tree1, true);
158 - 168: GuideTree.ToFile(f);
159 - 169: if (g_bClusterOnly)
170: GuideTree.Clear(); //valgrind 171: //GuideTree = 0;
160 - 172: return;
161 - 173: } 162 - 174:
165 - 177:
166 - 178: MSA msa;
167 - 179: ProgNode *ProgNodes = 0;
180: int PNlength = (msaInput->inputSeqs).Length();
168 - 181: if (g_bLow)
169 : ProgNodes = ProgressiveAlignE(v, GuideTree, msa);
182: ProgNodes = ProgressiveAlignE(msaInput->inputSeqs, GuideTree, msa);
170 - 183: else
171 : ProgressiveAlign(v, GuideTree, msa);
184: ProgressiveAlign(msaInput->inputSeqs, GuideTree, msa);
172 - 185: SetCurrentAlignment(msa);
173 - 186:
174 - 187: if (0 != g_pstrComputeWeightsFileName)
176 - 189: extern void OutWeights(const char *FileName, const MSA &msa);
177 - 190: SetMSAWeightsMuscle(msa);
178 - 191: OutWeights(g_pstrComputeWeightsFileName, msa);
192: GuideTree.Clear();
179 - 193: return;
180 - 194: } 181 - 195:
186 - 200: //TextFile fileOut(g_pstrOutFileName, true);
187 - 201: //MHackEnd(msa);
188 - 202: //msa.ToFile(fileOut);
189 : MuscleOutput(msa);
203: msaOutput->msa = MuscleOutput(msa);
204: GuideTree.Clear();
190 - 205: return;
191 - 206: } 192 - 207:
198 - 213: if (g_bLow) 199 - 214: {
200 - 215: if (0 != g_uMaxTreeRefineIters)
201 : RefineTreeE(msa, v, GuideTree, ProgNodes);
216: RefineTreeE(msa, msaInput->inputSeqs, GuideTree, ProgNodes);
202 - 217: } 203 - 218: else
204 - 219: RefineTree(msa, GuideTree);
232 - 247: //TextFile fileOut(g_pstrOutFileName, true);
233 - 248: //MHackEnd(msa);
234 - 249: //msa.ToFile(fileOut);
235 : MuscleOutput(msa);
236 : }
250: msaOutput->msa = MuscleOutput(msa);
237 - 251:
238 : void Run()
252: //GuideTree = 0;
253: extern void DeleteProgNode(ProgNode &Node);
254: const unsigned uNodeCount = GuideTree.GetNodeCount();
255: for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex) 256: DeleteProgNode(ProgNodes[uNodeIndex]); //valgrind
257:
258: delete[] ProgNodes;
259:
260: GuideTree.Clear(); //valgrind 261: return;
262: } 263:
264: void Run(MSAInput *msaInput, MSAOutput *msaOutput) 239 - 265: {
240 - 266: SetStartTime();
241 - 267: Log("Started %s\n", GetTimeAsStr());
271 - 297: DoMakeTree();
272 - 298: } 273 - 299: else
274 : DoMuscle();
300: DoMuscle(msaInput, msaOutput);
275 - 301:
276 - 302: #if TIMING
277 - 303: extern TICKS g_ticksDP;
296 - 322:
297 - 323: ListDiagSavings();
298 - 324: Log("Finished %s\n", GetTimeAsStr());
325:
299 - 326: }
C.1.6 ../msa/src/Muscle/domuscle.cpp
19 - 19: "please refer to the user guide. To disable this\n"
20 - 20: "warning, use -usetree_nowarn <treefilename>.\n\n";
21 - 21:
22 : void DoMuscle(MSAInput *msaInput, MSAOutput *msaOutput) 22: void DoMuscle(MuscleInput *msaInput, MuscleOutput *msaOutput) 23 - 23: {
24 - 24: SetOutputFileName(g_pstrOutFileName);
25 - 25: SetInputFileName(g_pstrInFileName);
200 - 200: //TextFile fileOut(g_pstrOutFileName, true);
201 - 201: //MHackEnd(msa);
202 - 202: //msa.ToFile(fileOut);
203 : msaOutput->msa = MuscleOutput(msa);
203: msaOutput->msa = DoMuscleOutput(msa);
204 - 204: GuideTree.Clear();
205 - 205: return;
206 - 206: }
247 - 247: //TextFile fileOut(g_pstrOutFileName, true);
248 - 248: //MHackEnd(msa);
249 - 249: //msa.ToFile(fileOut);
250 : msaOutput->msa = MuscleOutput(msa);
250: msaOutput->msa = DoMuscleOutput(msa);
251 - 251:
252 - 252: //GuideTree = 0;
253 - 253: extern void DeleteProgNode(ProgNode &Node);
261 - 261: return;
262 - 262: } 263 - 263:
264 : void Run(MSAInput *msaInput, MSAOutput *msaOutput) 264: void Run(MuscleInput *msaInput, MuscleOutput *msaOutput) 265 - 265: {
266 - 266: SetStartTime();
267 - 267: Log("Started %s\n", GetTimeAsStr());
C.1.7 ../msa/src/Muscle/estring.cpp
685 - 685: short esa[] = { 0 };
686 - 686: test(es1, es2, esa);
687 - 687: }
688 : exit(0);
688: throw 0;
689 - 689: }
C.1.8 ../msa/src/Muscle/fastdistjones.cpp
155 - 155: } 156 - 156: } 157 - 157: }
158 : delete[] SeqList;
C.1 MUSCLE
158: //delete[] SeqList;
159: free(SeqList); //valgrind 159 - 160: free(TripleCounts);
160 - 161:
161 - 162: unsigned uDone = 0;
C.1.9 ../msa/src/Muscle/fastdistmafft.cpp
141 - 141: L[n] = CharToLetterEx(c);
142 - 142: assert(L[n] < uResidueGroupCount);
143 - 143: }
144: //delete[] L; //valgrind 144 - 145: }
145 - 146:
146 - 147: unsigned **uCommonTupleCount = new unsigned *[uSeqCount];
273 - 274: for (unsigned n = 0; n < uSeqCount; ++n) 274 - 275: delete[] uCommonTupleCount[n];
275 - 276: delete[] uCommonTupleCount;
277: for (unsigned p = 0; p < uSeqCount; p++) 278: delete[] Letters[p];
276 - 279: delete[] Letters;
277 - 280: } 278 - 281:
C.1.10 ../msa/src/Muscle/glbalignle.cpp
2 - 2: #include "profile.h"
3 - 3: #include "pwpath.h"
4 - 4:
5: #if WIN32
6: #include <math.h>
7: #endif 8:
5 - 9: #define OCC 1 6 - 10:
7 - 11: struct DP_MEMORY
C.1.11 ../msa/src/Muscle/globals.cpp
55 - 55: if (NULL == f) 56 - 56: {
57 - 57: perror(g_strListFileName);
58 : exit(EXIT_NotStarted);
58: throw EXIT_NotStarted;
59 - 59: } 60 - 60:
61 - 61: char szStr[4096];
101 - 101: Break();
102 - 102: } 103 - 103: #endif
104 : exit(EXIT_FatalError);
104: throw EXIT_FatalError;
105 - 105: } 106 - 106:
107 - 107: void Warning(const char szFormat[], ...)
C.1.12 ../msa/src/Muscle/globalsosx.cpp
13 - 13: #include <netinet/icmp6.h>
14 - 14: #include <sys/vmmeter.h>
15 - 15: #include <sys/proc.h>
16: #include <mach/vm_statistics.h> //according to: https://github.com/markusn/homebrew/
commit/8fff24ba883e30778abbd29801b843654ba1bd41 16 - 17: #include <mach/task_info.h>
17 - 18: #include <mach/task.h>
18 - 19: #include <mach/mach_init.h>
19 : #include <mach/vm_statistics.h>
20 - 20:
21 - 21: const double DEFAULT_RAM = 1e9;
22 - 22: const double DEFAULT_MEM_USE = 1e6;
C.1.13 ../msa/src/Muscle/globalswin32.cpp
1 : #include "muscle.h"
1: /*#include "muscle.h"
2 - 2:
3 - 3: #if WIN32
4 - 4: #include <windows.h>
98 - 98: return dGHz;
99 - 99: }
100 - 100: #endif // WIN32
C.1.14 ../msa/src/Muscle/main.cpp
41 - 41: if (g_bVersion) 42 - 42: {
43 - 43: printf("%s\n", MUSCLE_LONG_VERSION);
44 : exit(EXIT_SUCCESS);
44: throw EXIT_SUCCESS;
45 - 45: } 46 - 46:
47 - 47: if (!g_bQuiet)
50 - 50: if (MissingCommand() && isatty(0)) 51 - 51: {
52 - 52: Usage();
53 : exit(EXIT_SUCCESS);
53: throw EXIT_SUCCESS;
54 - 54: } 55 - 55:
56 - 56: if (g_bCatchExceptions) 57 - 57: {
58 - 58: try 59 - 59: {
60 : Run();
60: //Run();
61 - 61: }
62 - 62: catch (...) 63 - 63: {
64 - 64: OnException();
65 : exit(EXIT_Except);
65: throw EXIT_Except;
66 - 66: } 67 - 67: }
68 : else
69 : Run();
68: else {
69: //Run();
70: }
70 - 71:
71 : exit(EXIT_Success);
72: throw EXIT_Success;
72 - 73: }
C.1.15 ../msa/src/Muscle/main.cpp
9 - 9: #include <unistd.h> // for isatty() 10 - 10: #endif
11 - 11:
12 : const char *MUSCLE_LONG_VERSION = "MUSCLE v" SHORT_VERSION "."
12: const char *MUSCLE_LONG_VERSION = "MUSCLE " SHORT_VERSION "."
13 - 13: #include "svnversion.h"
14 : " by Robert C. Edgar";
14: " ";
15 - 15:
16 - 16: int g_argc;
17 - 17: char **g_argv;
C.1.16 ../msa/src/Muscle/msa.cpp
26 - 26:
27 - 27: MSA::˜MSA() 28 - 28: {
29 : Free();
29: FreeAll();
30 - 30: } 31 - 31:
32 : void MSA::Free() 32: void MSA::FreeAll() 33 - 33: {
34 - 34: for (unsigned n = 0; n < m_uSeqCount; ++n) 35 - 35: {
56 - 56:
57 - 57: void MSA::SetSize(unsigned uSeqCount, unsigned uColCount) 58 - 58: {
59 : Free();
59: FreeAll();
C.1 MUSCLE
60 - 60:
61 - 61: m_uSeqCount = uSeqCount;
62 - 62: m_uCacheSeqLength = uColCount;
263 - 263:
264 - 264: void MSA::SetSeqCount(unsigned uSeqCount) 265 - 265: {
266 : Free();
266: FreeAll();
267 - 267: SetSize(uSeqCount, DEFAULT_SEQ_LENGTH);
268 - 268: } 269 - 269:
283 - 283:
284 - 284: void MSA::Copy(const MSA &msa) 285 - 285: {
286 : Free();
286: FreeAll();
287 - 287: const unsigned uSeqCount = msa.GetSeqCount();
288 - 288: const unsigned uColCount = msa.GetColCount();
289 - 289: SetSize(uSeqCount, uColCount);
C.1.17 ../msa/src/Muscle/msa.h
1 - 1: #ifndef MSA_h 2 - 2: #define MSA_h 3 - 3:
4: #include <vector>
5: #include <string>
6: using namespace std;
7:
4 - 8: const int MAX_SEQ_NAME = 63;
5 - 9: struct PathEdge;
6 - 10: class TextFile;
25 - 29: void ToFASTAFile(TextFile &File) const;
26 - 30: void ToMSFFile(TextFile &File, const char *ptrComment = 0) const;
27 - 31: void ToAlnFile(TextFile &File) const;
32: vector<string> ToAlnFile() const;
28 - 33: void ToHTMLFile(TextFile &File) const;
29 - 34: void ToPhySequentialFile(TextFile &File) const;
30 - 35: void ToPhyInterleavedFile(TextFile &File) const;
103 - 108:
104 - 109: void Clear() 105 - 110: {
106 : Free();
111: FreeAll();
107 - 112: }
108 - 113: unsigned GetSeqCount() const 109 - 114: {
128 - 133: void SetUniformWeights() const;
129 - 134: void SetClustalWWeights(const Tree &tree);
130 - 135:
131 : void Free();
136: void FreeAll();
132 - 137: void AppendSeq(char *ptrSeq, unsigned uSeqLength, char *ptrLabel);
133 - 138: void ExpandCache(unsigned uSeqCount, unsigned uColCount);
134 - 139: void CalcWeights() const;
C.1.18 ../msa/src/Muscle/muscle.h
1: #include <vector>
2: #include <string>
3:
1 - 4: #if DEBUG && !_DEBUG 2 - 5: #define _DEBUG 1 3 - 6: #endif
26 - 29: #include <stdarg.h>
27 - 30: #include <stdio.h>
28 - 31:
32:
29 - 33: #define DOUBLE_AFFINE 0 30 - 34: #define SINGLE_AFFINE 1
31 - 35: #define PAF 0
134 - 138: void VectorSet(float dValues[], unsigned n, float d);
135 - 139:
136 - 140: // @@TODO should be "not linux"
137 : #if _WIN32 141: /*#if _WIN32
138 - 142: double log2(double x); // Defined in <math.h> on Linux 139 : #endif
143: #endif*/
140 - 144:
141 - 145: double pow2(double x);
142 - 146: double lnTolog2(double ln);
244 - 248: void SetSeqStats(unsigned uSeqCount, unsigned uMaxL, unsigned uAvgL);
245 - 249:
246 - 250: void SetNewHandler();
251: void CleanupNewHandler();
247 - 252: void SaveCurrentAlignment();
248 - 253: void SetCurrentAlignment(MSA &msa);
249 - 254: void SetOutputFileName(const char *out);
270 - 275:
271 - 276: bool FlagOpt(const char *Name);
272 - 277: const char *ValueOpt(const char *Name);
273 : void DoMuscle();
278: //void DoMuscle(MSAInput msaInput, MSAOutput *msaOutput);
274 - 279: void ProfDB();
275 - 280: void DoSP();
276 - 281: void ProgAlignSubFams();
277 : void Run();
282: //void Run(MSAInput msaInput, MSAOutput *msaOutput);
278 - 283: void ListParams();
279 - 284: void OnException();
280 - 285: void SetSeqWeightMethod(SEQWEIGHT Method);
324 - 329: void WriteScoreFile(const MSA &msa);
325 - 330: char ConsensusChar(const ProfPos &PP);
326 - 331: void Stabilize(const MSA &msa, MSA &msaStable);
327 : void MuscleOutput(MSA &msa);
332: std::vector<std::string> MuscleOutput(MSA &msa);
328 - 333: PTR_SCOREMATRIX ReadMx(TextFile &File);
334: PTR_SCOREMATRIX ReadMxFromR(std::vector<std::string> colnames, float matrix[32][32])
;
329 - 335: void MemPlus(size_t Bytes, char *Where);
330 - 336: void MemMinus(size_t Bytes, char *Where);
C.1.19 ../msa/src/Muscle/muscle.h
275 - 275:
276 - 276: bool FlagOpt(const char *Name);
277 - 277: const char *ValueOpt(const char *Name);
278 : //void DoMuscle(MSAInput msaInput, MSAOutput *msaOutput);
278: //void DoMuscle(MuscleInput msaInput, MuscleOutput *msaOutput);
279 - 279: void ProfDB();
280 - 280: void DoSP();
281 - 281: void ProgAlignSubFams();
282 : //void Run(MSAInput msaInput, MSAOutput *msaOutput);
282: //void Run(MuscleInput msaInput, MuscleOutput *msaOutput);
283 - 283: void ListParams();
284 - 284: void OnException();
285 - 285: void SetSeqWeightMethod(SEQWEIGHT Method);
329 - 329: void WriteScoreFile(const MSA &msa);
330 - 330: char ConsensusChar(const ProfPos &PP);
331 - 331: void Stabilize(const MSA &msa, MSA &msaStable);
332 : std::vector<std::string> MuscleOutput(MSA &msa);
332: std::vector<std::string> DoMuscleOutput(MSA &msa);
333 - 333: PTR_SCOREMATRIX ReadMx(TextFile &File);
334 - 334: PTR_SCOREMATRIX ReadMxFromR(std::vector<std::string> colnames, float matrix [32][32]);
335 - 335: void MemPlus(size_t Bytes, char *Where);
C.1.20 ../msa/src/Muscle/muscleout.cpp
2 - 2: #include "msa.h"
3 - 3: #include "params.h"
4 - 4: #include "textfile.h"
5: #include <vector>
6: #include <string>
7: using namespace std;
5 - 8:
6 : static void DoOutput(MSA &msa)
9: static vector<string> DoOutput(MSA &msa) 7 - 10: {
8 - 11: bool AnyOutput = false;
12: vector<string> result;
9 - 13:
10 - 14: // Value options
11 - 15: if (g_pstrFASTAOutFileName) 25 - 29: if (g_pstrClwOutFileName) 26 - 30: {
27 - 31: TextFile File(g_pstrClwOutFileName, true);
28 : msa.ToAlnFile(File);
32: result = msa.ToAlnFile();
29 - 33: AnyOutput = true;
30 - 34: }
31 :
32 - 35: if (g_pstrClwStrictOutFileName) 33 - 36: {
34 - 37: g_bClwStrict = true;
35 - 38: TextFile File(g_pstrClwStrictOutFileName, true);
36 : msa.ToAlnFile(File);
39: result = msa.ToAlnFile();
37 - 40: AnyOutput = true;
38 - 41: } 39 - 42:
C.1 MUSCLE
72 - 75: }
73 - 76: else if (g_bAln) 74 - 77: {
75 : msa.ToAlnFile(fileOut);
78: result = msa.ToAlnFile();
76 - 79: AnyOutput = true;
77 - 80: }
78 - 81: else if (g_bHTML) 92 - 95: }
93 - 96:
94 - 97: // If -out option was given but no flags, output as FASTA 95 : if (!AnyOutput)
98: if (!AnyOutput) { 96 - 99: msa.ToFASTAFile(fileOut);
97 :
98 : fileOut.Close();
100: }
101: //fileOut.Close();
99 - 102:
100 : if (0 != g_pstrScoreFileName) 103: if (0 != g_pstrScoreFileName) { 101 - 104: WriteScoreFile(msa);
102 - 105: }
106: return result;
107: } 103 - 108:
104 : void MuscleOutput(MSA &msa)
109: vector<string> MuscleOutput(MSA &msa) 105 - 110: {
106 - 111: MHackEnd(msa);
107 - 112: if (g_bStable) 109 - 114: MSA msaStable;
110 - 115: Stabilize(msa, msaStable);
111 - 116: msa.Clear(); // save memory 112 : DoOutput(msaStable);
117: return DoOutput(msaStable);
113 - 118: }
114 : else
115 : DoOutput(msa);
119: return DoOutput(msa);
116 - 120: }
C.1.21 ../msa/src/Muscle/muscleout.cpp
106 - 106: return result;
107 - 107: } 108 - 108:
109 : vector<string> MuscleOutput(MSA &msa) 109: vector<string> DoMuscleOutput(MSA &msa) 110 - 110: {
111 - 111: MHackEnd(msa);
112 - 112: if (g_bStable)
C.1.22 ../msa/src/Muscle/objscore.cpp
104 - 104: delete[] SeqIndexes2;
105 - 105: #else
106 - 106: SCORE dObjScore = ObjScore(msa, SeqIndexes1, uCount1, SeqIndexes2, uCount2);
107: delete[] SeqIndexes1; //valgrind 108: delete[] SeqIndexes2; //valgrind 107 - 109: #endif
108 - 110: #if TIMING
109 - 111: TICKS t2 = GetClockTicks();
C.1.23 ../msa/src/Muscle/onexception.cpp
11 - 11: fprintf(stderr, "%s", szOnExceptionMessage);
12 - 12: Log("%s", szOnExceptionMessage);
13 - 13: Log("Finished %s\n", GetTimeAsStr());
14 : exit(EXIT_Except);
14: throw EXIT_Except;
15 - 15: }
C.1.24 ../msa/src/Muscle/options.cpp
143 - 143: if (0 == Value) 144 - 144: {
145 - 145: fprintf(stderr, "Option -%s must have value\n", Arg);
146 : exit(EXIT_NotStarted);
146: throw EXIT_NotStarted;
147 - 147: }
148 - 148: ValueOpts[i].m_pstrValue = strsave(Value);
149 - 149: return true;
177 - 177: if (Arg[0] != ’-’) 178 - 178: {
179 - 179: fprintf(stderr, "Command-line option \"%s\" must start with ’-’\n", Arg);
180 : exit(EXIT_NotStarted);
180: throw EXIT_NotStarted;
181 - 181: }
182 - 182: const char *ArgName = Arg + 1;
183 - 183: if (TestSetFlagOpt(ArgName)) 196 - 196: }
197 - 197: fprintf(stderr, "Invalid command line option \"%s\"\n", ArgName);
198 - 198: Usage();
199 : exit(EXIT_NotStarted);
199: throw EXIT_NotStarted;
200 - 200: } 201 - 201: } 202 - 202:
C.1.25 ../msa/src/Muscle/phyfromclust.cpp
1 - 1: #include "muscle.h"
2 - 2: #include "tree.h"
3 - 3: #include "clust.h"
4: #include "gc_cpp.h"
4 - 5:
5 - 6: void Tree::InitCache(unsigned uCacheCount) 6 - 7: {
7 - 8: m_uCacheCount = uCacheCount;
8 - 9:
9 : m_uNeighbor1 = new unsigned[m_uCacheCount];
10 : m_uNeighbor2 = new unsigned[m_uCacheCount];
11 : m_uNeighbor3 = new unsigned[m_uCacheCount];
10: m_uNeighbor1 = new (UseGC) unsigned[m_uCacheCount];
11: m_uNeighbor2 = new (UseGC) unsigned[m_uCacheCount];
12: m_uNeighbor3 = new (UseGC) unsigned[m_uCacheCount];
12 - 13:
13 - 14: m_Ids = new unsigned[m_uCacheCount];
14 - 15:
C.1.26 ../msa/src/Muscle/phyfromclust.cpp
1 - 1: #include "muscle.h"
2 - 2: #include "tree.h"
3 - 3: #include "clust.h"
4 : #include "gc_cpp.h"
5 - 4:
6 - 5: void Tree::InitCache(unsigned uCacheCount) 7 - 6: {
8 - 7: m_uCacheCount = uCacheCount;
9 - 8:
10 : m_uNeighbor1 = new (UseGC) unsigned[m_uCacheCount];
11 : m_uNeighbor2 = new (UseGC) unsigned[m_uCacheCount];
12 : m_uNeighbor3 = new (UseGC) unsigned[m_uCacheCount];
9: m_uNeighbor1 = new unsigned[m_uCacheCount];
10: m_uNeighbor2 = new unsigned[m_uCacheCount];
11: m_uNeighbor3 = new unsigned[m_uCacheCount];
13 - 12:
14 - 13: m_Ids = new unsigned[m_uCacheCount];
15 - 14:
C.1.27 ../msa/src/Muscle/profile.h
3 - 3:
4 - 4: #include "msa.h"
5 - 5: #include "pwpath.h"
6 : #include <math.h> // for log function 7 - 6:
7: #if !WIN32
8: #include <math.h> // for log function 9: #endif
10:
8 - 11: class DiagList;
9 - 12: class WeightList;
10 - 13:
C.1 MUSCLE
C.1.28 ../msa/src/Muscle/profile.cpp
143 - 143: ProfileProfile(msa1, msa2, msaOut);
144 - 144:
145 - 145: Progress("Writing output");
146 : MuscleOutput(msaOut);
146: DoMuscleOutput(msaOut);
147 - 147: }
C.1.29 ../msa/src/Muscle/readmx.cpp
4 - 4: #define TRACE 0 5 - 5:
6 - 6: const int MAX_LINE = 4096;
7 : const int MAX_HEADINGS = 32;
7: const int MAX_HEADINGS = 20;
8 - 8: static char Heading[MAX_HEADINGS];
9 - 9: static unsigned HeadingCount = 0;
10 - 10: static float Mx[32][32];
111 - 111:
112 - 112: char *p = Line + 1;
113 - 113: char *maxp = p + strlen(Line);
114 : for (unsigned Col = 0; Col < HeadingCount - 1; ++Col) 114: for (unsigned Col = 0; Col < HeadingCount; ++Col) 115 - 115: {
116 - 116: if (p >= maxp)
117 - 117: Quit("Too few fields in line of matrix file: ’%s’", Line);
172 - 172:
173 - 173: #if TRACE 174 - 174: {
175 : Log("ReadMx\n");
175: Log("ReadMxFromR\n");
176 - 176: Log("%d headings: ", HeadingCount);
177 - 177: for (unsigned i = 0; i < HeadingCount; ++i) 178 - 178: Log("%c", Heading[i]);
210 - 210: Log("Row letter = %u\n", RowLetter);
211 - 211: #endif 212 - 212:
213 : for (unsigned Col = 0; Col < HeadingCount - 1; ++Col) { 213: for (unsigned Col = 0; Col < HeadingCount; ++Col) { 214 - 214: char HeaderChar = Heading[Col];
215 - 215: //printf("Header char: %c\n", HeaderChar);
216 - 216: if (IsResidueChar(HeaderChar)) {
C.1.30 ../msa/src/Muscle/realigndiffse.cpp
10 - 10:
11 - 11: void DeleteProgNode(ProgNode &Node) 12 - 12: {
13 : delete[] Node.m_Prof;
14 : delete[] Node.m_EstringL;
15 : delete[] Node.m_EstringR;
13: ProgNode *temp = &Node;
14: if (!temp) {
15: if (NULL != Node.m_Prof) { 16: delete[] Node.m_Prof;
17: }
18: delete[] Node.m_EstringL;
19: delete[] Node.m_EstringR;
16 - 20:
17 : Node.m_Prof = 0;
18 : Node.m_EstringL = 0;
19 : Node.m_EstringR = 0;
21: Node.m_Prof = 0;
22: Node.m_EstringL = 0;
23: Node.m_EstringR = 0;
20 - 24: }
25: }
21 - 26:
22 - 27: static void MakeNode(ProgNode &OldNode, ProgNode &NewNode, bool bSwapLR) 23 - 28: {
C.1.31 ../msa/src/Muscle/refine.cpp
76 - 76:
77 - 77: // TextFile fileOut(g_pstrOutFileName, true);
78 - 78: // msa.ToFile(fileOut);
79 : MuscleOutput(msa);
79: DoMuscleOutput(msa);
80 - 80: }
C.1.32 ../msa/src/Muscle/refinehoriz.cpp
53 - 53: DeleteGappedCols(msa1);
54 - 54: DeleteGappedCols(msa2);
55 - 55:
56 : if (0 == msa1.GetColCount() || 0 == msa2.GetColCount()) 56: if (0 == msa1.GetColCount() || 0 == msa2.GetColCount()) { 57: delete[] Ids1; //valgrind
58: delete[] Ids2; //valgrind 57 - 59: return false;
60: }
58 - 61:
59 - 62: MSA msaRealigned;
60 - 63: PWPath pathAfter;
77 - 80: msaRealigned.LogMe();
78 - 81: #endif 79 - 82:
80 : if (!bAnyChanges)
81 : {
83: if (!bAnyChanges) { 82 - 84: *ptrscoreBefore = 0;
83 - 85: *ptrscoreAfter = 0;
86: delete[] Ids1; //valgrind 87: delete[] Ids2; //valgrind 84 - 88: return false;
85 : }
89: }
86 - 90:
87 - 91: SetMSAWeightsMuscle(msaIn);
88 - 92: SetMSAWeightsMuscle(msaRealigned);
C.1.33 ../msa/src/Muscle/refinetreee.cpp
48 - 48:
49 - 49: SetCurrentAlignment(msa);
50 - 50: ProgressStepsDone();
51: Tree2.Clear();
51 - 52: }
C.1.34 ../msa/src/Muscle/refinew.cpp
152 - 152:
153 - 153: _CrtMemDumpStatistics(&s);
154 - 154: _CrtMemDumpAllObjectsSince(&s1);
155 : exit(1);
155: throw 1;
156 - 156: #endif
157 - 157: //#if DEBUG
158 - 158: // AssertMSAEqIgnoreCaseAndGaps(msaInTmp, msaTmp);
C.1.35 ../msa/src/Muscle/refinew.cpp
223 - 223:
224 - 224: // TextFile fileOut(g_pstrOutFileName, true);
225 - 225: // msaOut.ToFile(fileOut);
226 : MuscleOutput(msaOut);
226: DoMuscleOutput(msaOut);
227 - 227: }
C.1.36 ../msa/src/Muscle/savebest.cpp
23 - 23: {
24 - 24: fprintf(stderr,
25 - 25: "\nRecursive call to SaveCurrentAlignment, giving up attempt to save.\n");
26 : exit(EXIT_FatalError);
26: throw EXIT_FatalError;
27 - 27: } 28 - 28:
29 - 29: if (0 == ptrBestMSA) 30 - 30: {
31 - 31: fprintf(stderr, "\nAlignment not completed, cannot save.\n");
32 - 32: Log("Alignment not completed, cannot save.\n");
33 : exit(EXIT_FatalError);
33: throw EXIT_FatalError;
C.1 MUSCLE
34 - 34: } 35 - 35:
36 - 36: if (0 == pstrOutputFileName) 37 - 37: {
38 - 38: fprintf(stderr, "\nOutput file name not specified, cannot save.\n");
39 : exit(EXIT_FatalError);
39: throw EXIT_FatalError;
40 - 40: } 41 - 41:
42 - 42: fprintf(stderr, "\nSaving current alignment ...\n");
62 - 62: MaxSecsToStr(), ElapsedSecs);
63 - 63:
64 - 64: SaveCurrentAlignment();
65 : exit(EXIT_Success);
65: throw EXIT_Success;
66 - 66: }
C.1.37 ../msa/src/Muscle/scorepp.cpp
1 - 1: #include "muscle.h"
2 - 2: #include "profile.h"
3 - 3:
4: #if WIN32
5: #include <math.h>
6: #endif 7:
4 - 8: char ConsensusChar(const ProfPos &PP) 5 - 9: {
6 - 10: unsigned uMostCommonLetter = 0;
C.1.38 ../msa/src/Muscle/seq.cpp
311 - 311: for (unsigned uColIndex = 0; uColIndex < uLength; ++uColIndex) 312 - 312: push_back(pstrSeq[uColIndex]);
313 - 313: size_t n = strlen(pstrName) + 1;
314: delete[] m_ptrName; //valgrind 314 - 315: m_ptrName = new char[n];
315 - 316: strcpy(m_ptrName, pstrName);
316 - 317: }
C.1.39 ../msa/src/Muscle/seq.h
14 - 14: Seq() 15 - 15: {
16 - 16: m_ptrName = 0;
17: m_uId = 0;
17 - 18: // Start with moderate size to avoid 18 - 19: // thrashing the heap.
19 - 20: reserve(200);
C.1.40 ../msa/src/Muscle/setnewhandler.cpp
16 - 16: fprintf(stderr, "No alignment generated\n");
17 - 17: else
18 - 18: SaveCurrentAlignment();
19 : exit(EXIT_FatalError);
19: throw EXIT_FatalError;
20 - 20: } 21 - 21:
22 - 22: void SetNewHandler()
24 - 24: EmergencyReserve = malloc(RESERVE_BYTES);
25 - 25: std::set_new_handler(OnOutOfMemory);
26 - 26: }
C.1.41 ../msa/src/Muscle/timing.h
5 - 5: #pragma warning(disable:4035) 6 - 6: inline TICKS GetClockTicks() 7 - 7: {
8 : _asm
8: /*_asm 9 - 9: {
10 - 10: _emit 0x0f 11 - 11: _emit 0x31
12 : }
12: }*/
13: asm("emit, 0x0f");
14: asm("emit, 0x31");
13 - 15: } 14 - 16:
15 - 17: #define StartTimer() __int64 t1__ = GetClockTicks()
C.1.42 ../msa/src/Muscle/timing.h
3 - 3: typedef unsigned __int64 TICKS;
4 - 4:
5 - 5: #pragma warning(disable:4035) 6 : inline TICKS GetClockTicks()
7 : {
8 : /*_asm
9 : {
10 : _emit 0x0f
11 : _emit 0x31
12 : }*/
13 : asm("emit, 0x0f");
14 : asm("emit, 0x31");
15 : }
6: inline TICKS GetClockTicks() { 7: unsigned __int64 mmRet;
8: /*_asm
9: {
10: _emit 0x0f
11: _emit 0x31
12: }*/
13: asm("emit, 0x0f");
14: asm("emit, 0x31");
15: asm("mov dword ptr [mmRet+0],eax");
16: asm("mov dword ptr [mmRet+4],edx");
17: return mmRet;
18: } 16 - 19:
17 - 20: #define StartTimer() __int64 t1__ = GetClockTicks() 18 - 21:
C.1.43 ../msa/src/Muscle/tree.h
54 - 54: void Clear() 55 - 55: {
56 - 56: for (unsigned n = 0; n < m_uNodeCount; ++n)
57: {
57 - 58: free(m_ptrName[n]);
59: }
58 - 60:
59 - 61: m_uNodeCount = 0;
60 - 62: m_uCacheCount = 0;
79 - 81: m_dEdgeLength1 = 0;
80 - 82: m_dEdgeLength2 = 0;
81 - 83: m_dEdgeLength3 = 0;
84: m_bHasEdgeLength1 = 0;
85: m_bHasEdgeLength2 = 0;
86: m_bHasEdgeLength3 = 0;
82 - 87: m_ptrName = 0;
83 - 88: m_Ids = 0;
84 - 89: m_uRootNodeIndex = 0;
C.1.44 ../msa/src/Muscle/tree.h
61 - 61: m_uNodeCount = 0;
62 - 62: m_uCacheCount = 0;
63 - 63:
64 : delete[] m_uNeighbor1;
64: //GC cleanup
65: /*delete[] m_uNeighbor1;
65 - 66: delete[] m_uNeighbor2;
66 : delete[] m_uNeighbor3;
67: delete[] m_uNeighbor3;*/
67 - 68: delete[] m_dEdgeLength1;
68 - 69: delete[] m_dEdgeLength2;
69 - 70: delete[] m_dEdgeLength3;
C.1.45 ../msa/src/Muscle/aln.cpp
C.1 MUSCLE
96 - 96:
97 - 97: string line = "";
98 - 98: vector<string> result;
99 : line = string(MUSCLE_LONG_VERSION) + string(" - multiple sequence alignment");
99: line = string(MUSCLE_LONG_VERSION) + string(" ");
100 - 100: result.push_back(line);
101 - 101: line = "";
102 - 102: result.push_back("");
C.1.46 ../msa/src/Muscle/domuscle.cpp
19 - 19: "please refer to the user guide. To disable this\n"
20 - 20: "warning, use -usetree_nowarn <treefilename>.\n\n";
21 - 21:
22 : void DoMuscle(MSAInput *msaInput, MSAOutput *msaOutput) 22: void DoMuscle(MuscleInput *msaInput, MuscleOutput *msaOutput) 23 - 23: {
24 - 24: SetOutputFileName(g_pstrOutFileName);
25 - 25: SetInputFileName(g_pstrInFileName);
200 - 200: //TextFile fileOut(g_pstrOutFileName, true);
201 - 201: //MHackEnd(msa);
202 - 202: //msa.ToFile(fileOut);
203 : msaOutput->msa = MuscleOutput(msa);
203: msaOutput->msa = DoMuscleOutput(msa);
204 - 204: GuideTree.Clear();
205 - 205: return;
206 - 206: }
247 - 247: //TextFile fileOut(g_pstrOutFileName, true);
248 - 248: //MHackEnd(msa);
249 - 249: //msa.ToFile(fileOut);
250 : msaOutput->msa = MuscleOutput(msa);
250: msaOutput->msa = DoMuscleOutput(msa);
251 - 251:
252 - 252: //GuideTree = 0;
253 - 253: extern void DeleteProgNode(ProgNode &Node);
261 - 261: return;
262 - 262: } 263 - 263:
264 : void Run(MSAInput *msaInput, MSAOutput *msaOutput) 264: void Run(MuscleInput *msaInput, MuscleOutput *msaOutput) 265 - 265: {
266 - 266: SetStartTime();
267 - 267: Log("Started %s\n", GetTimeAsStr());
C.1.47 ../msa/src/Muscle/main.cpp
9 - 9: #include <unistd.h> // for isatty() 10 - 10: #endif
11 - 11:
12 : const char *MUSCLE_LONG_VERSION = "MUSCLE v" SHORT_VERSION "."
12: const char *MUSCLE_LONG_VERSION = "MUSCLE " SHORT_VERSION "."
13 - 13: #include "svnversion.h"
14 : " by Robert C. Edgar";
14: " ";
15 - 15:
16 - 16: int g_argc;
17 - 17: char **g_argv;
C.1.48 ../msa/src/Muscle/muscle.h
275 - 275:
276 - 276: bool FlagOpt(const char *Name);
277 - 277: const char *ValueOpt(const char *Name);
278 : //void DoMuscle(MSAInput msaInput, MSAOutput *msaOutput);
278: //void DoMuscle(MuscleInput msaInput, MuscleOutput *msaOutput);
279 - 279: void ProfDB();
280 - 280: void DoSP();
281 - 281: void ProgAlignSubFams();
282 : //void Run(MSAInput msaInput, MSAOutput *msaOutput);
282: //void Run(MuscleInput msaInput, MuscleOutput *msaOutput);
283 - 283: void ListParams();
284 - 284: void OnException();
285 - 285: void SetSeqWeightMethod(SEQWEIGHT Method);
329 - 329: void WriteScoreFile(const MSA &msa);
330 - 330: char ConsensusChar(const ProfPos &PP);
331 - 331: void Stabilize(const MSA &msa, MSA &msaStable);
332 : std::vector<std::string> MuscleOutput(MSA &msa);
332: std::vector<std::string> DoMuscleOutput(MSA &msa);
333 - 333: PTR_SCOREMATRIX ReadMx(TextFile &File);
334 - 334: PTR_SCOREMATRIX ReadMxFromR(std::vector<std::string> colnames, float matrix [32][32]);
335 - 335: void MemPlus(size_t Bytes, char *Where);