Mercurial > repos > iuc > raxml

comparison raxml.py @ 0:934206441123 draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload for repository https://github.com/stamatak/standard-RAxML commit baa6a1ec8b3c440cdf73409ccaafcd303e9f4e72
author iuc
date Mon, 30 Nov 2015 22:03:09 -0500
parents
children b0d6eb76ad87
comparison
equal deleted inserted replaced
-1:000000000000 0:934206441123
1 #!/usr/bin/env python
2 """
3 Runs RAxML on a sequence file.
4 For use with RAxML version 8.2.4
5 """
6 import os, shutil, subprocess, sys, optparse, fnmatch, glob
7
8 def stop_err(msg):
9 sys.stderr.write("%s\n" % msg)
10 sys.exit()
11
12 def getint(name):
13 basename = name.partition('RUN.')
14 if basename[2] != '':
15 num = basename[2]
16 return int(num)
17
18 def __main__():
19 usage = "usage: %prog -T <threads> -s <input> -n <output> -m <model> [optional arguments]"
20
21 # Parse the primary wrapper's command line options
22 parser = optparse.OptionParser(usage = usage)
23 # raxml binary name, hardcoded in the xml file
24 parser.add_option("--binary", action="store", type="string", dest="binary", help="Command to run")
25 # (-a)
26 parser.add_option("--weightfile", action="store", type="string", dest="weightfile", help="Column weight file")
27 # (-A)
28 parser.add_option("--secondary_structure_model", action="store", type="string", dest="secondary_structure_model", help="Secondary structure model")
29 # (-b)
30 parser.add_option("--bootseed", action="store", type="int", dest="bootseed", help="Bootstrap random number seed")
31 # (-c)
32 parser.add_option("--numofcats", action="store", type="int", dest="numofcats", help="Number of distinct rate categories")
33 # (-d)
34 parser.add_option("--search_complete_random_tree", action="store_true", dest="search_complete_random_tree", help="Search with a complete random starting tree")
35 # (-D)
36 parser.add_option("--ml_search_convergence", action="store_true", dest="ml_search_convergence", help="ML search onvergence criterion")
37 # (-e)
38 parser.add_option("--model_opt_precision", action="store", type="float", dest="model_opt_precision", help="Model Optimization Precision (-e)")
39 # (-E)
40 parser.add_option("--excludefile", action="store", type="string", dest="excludefile", help="Exclude File Name")
41 # (-f)
42 parser.add_option("--search_algorithm", action="store", type="string", dest="search_algorithm", help="Search Algorithm")
43 # (-F)
44 parser.add_option("--save_memory_cat_model", action="store_true", dest="save_memory_cat_model", help="Save memory under CAT and GTRGAMMA models")
45 # (-g)
46 parser.add_option("--groupingfile", action="store", type="string", dest="groupingfile", help="Grouping File Name")
47 # (-G)
48 parser.add_option("--enable_evol_heuristics", action="store_true", dest="enable_evol_heuristics", help="Enable evol algo heuristics")
49 # (-i)
50 parser.add_option("--initial_rearrangement_setting", action="store", type="int", dest="initial_rearrangement_setting", help="Initial Rearrangement Setting")
51 # (-I)
52 parser.add_option("--posterior_bootstopping_analysis", action="store", type="string", dest="posterior_bootstopping_analysis", help="Posterior bootstopping analysis")
53 # (-J)
54 parser.add_option("--majority_rule_consensus", action="store", type="string", dest="majority_rule_consensus", help="Majority rule consensus")
55 # (-k)
56 parser.add_option("--print_branch_lengths", action="store_true", dest="print_branch_lengths", help="Print branch lengths")
57 # (-K)
58 parser.add_option("--multistate_sub_model", action="store", type="string", dest="multistate_sub_model", help="Multistate substitution model")
59 # (-m)
60 parser.add_option("--model_type", action="store", type="string", dest="model_type", help="Model Type")
61 parser.add_option("--base_model", action="store", type="string", dest="base_model", help="Base Model")
62 parser.add_option("--aa_empirical_freq", action="store_true", dest="aa_empirical_freq", help="Use AA Empirical base frequences")
63 parser.add_option("--aa_search_matrix", action="store", type="string", dest="aa_search_matrix", help="AA Search Matrix")
64 # (-n)
65 parser.add_option("--name", action="store", type="string", dest="name", help="Run Name")
66 # (-N/#)
67 parser.add_option("--number_of_runs", action="store", type="int", dest="number_of_runs", help="Number of alternative runs")
68 parser.add_option("--number_of_runs_bootstop", action="store", type="string", dest="number_of_runs_bootstop", help="Number of alternative runs based on the bootstop criteria")
69 # (-M)
70 parser.add_option("--estimate_individual_branch_lengths", action="store_true", dest="estimate_individual_branch_lengths", help="Estimate individual branch lengths")
71 # (-o)
72 parser.add_option("--outgroup_name", action="store", type="string", dest="outgroup_name", help="Outgroup Name")
73 # (-O)
74 parser.add_option("--disable_undetermined_seq_check", action="store_true", dest="disable_undetermined_seq_check", help="Disable undetermined sequence check")
75 # (-p)
76 parser.add_option("--random_seed", action="store", type="int", dest="random_seed", help="Random Number Seed")
77 # (-P)
78 parser.add_option("--external_protein_model", action="store", type="string", dest="external_protein_model", help="External Protein Model")
79 # (-q)
80 parser.add_option("--multiple_model", action="store", type="string", dest="multiple_model", help="Multiple Model File")
81 # (-r)
82 parser.add_option("--constraint_file", action="store", type="string", dest="constraint_file", help="Constraint File")
83 # (-R)
84 parser.add_option("--bin_model_parameter_file", action="store", type="string", dest="bin_model_parameter_file", help="Constraint File")
85 # (-s)
86 parser.add_option("--source", action="store", type="string", dest="source", help="Input file")
87 # (-S)
88 parser.add_option("--secondary_structure_file", action="store", type="string", dest="secondary_structure_file", help="Secondary structure file")
89 # (-t)
90 parser.add_option("--starting_tree", action="store", type="string", dest="starting_tree", help="Starting Tree")
91 # (-T)
92 parser.add_option("--threads", action="store", type="int", dest="threads", help="Number of threads to use")
93 # (-u)
94 parser.add_option("--use_median_approximation", action="store_true", dest="use_median_approximation", help="Use median approximation")
95 # (-U)
96 parser.add_option("--save_memory_gappy_alignments", action="store_true", dest="save_memory_gappy_alignments", help="Save memory in large gapped alignments")
97 # (-V)
98 parser.add_option("--disable_rate_heterogeneity", action="store_true", dest="disable_rate_heterogeneity", help="Disable rate heterogeneity")
99 # (-W)
100 parser.add_option("--sliding_window_size", action="store", type="string", dest="sliding_window_size", help="Sliding window size")
101 # (-x)
102 parser.add_option("--rapid_bootstrap_random_seed", action="store", type="int", dest="rapid_bootstrap_random_seed", help="Rapid Boostrap Random Seed")
103 # (-y)
104 parser.add_option("--parsimony_starting_tree_only", action="store_true", dest="parsimony_starting_tree_only", help="Generate a parsimony starting tree only")
105 # (-z)
106 parser.add_option("--file_multiple_trees", action="store", type="string", dest="file_multiple_trees", help="Multiple Trees File")
107
108 (options, args) = parser.parse_args()
109 cmd = []
110
111 # Required parameters
112 binary = options.binary
113 cmd.append(binary)
114 # Threads
115 if options.threads > 1:
116 threads = "-T %d" % options.threads
117 cmd.append(threads)
118 # Source
119 source = "-s %s" % options.source
120 cmd.append(source)
121 #Hardcode to "galaxy" first to simplify the output part of the wrapper
122 #name = "-n %s" % options.name
123 name = "-n galaxy"
124 cmd.append(name)
125 ## Model
126 model_type = options.model_type
127 base_model = options.base_model
128 aa_search_matrix = options.aa_search_matrix
129 aa_empirical_freq = options.aa_empirical_freq
130 if model_type == 'aminoacid':
131 model = "-m %s%s" % (base_model, aa_search_matrix)
132 if aa_empirical_freq:
133 model = "-m %s%s%s" % (base_model, aa_search_matrix, 'F')
134 # (-P)
135 if options.external_protein_model:
136 external_protein_model = "-P %s" % options.external_protein_model
137 cmd.append(external_protein_model)
138 else:
139 model = "-m %s" % base_model
140 cmd.append(model)
141 if model == "GTRCAT":
142 # (-c)
143 if options.numofcats:
144 numofcats = "-c %d" % options.numofcats
145 cmd.append(numofcats)
146 # Optional parameters
147 if options.number_of_runs_bootstop:
148 number_of_runs_bootstop = "-N %s" % options.number_of_runs_bootstop
149 cmd.append(number_of_runs_bootstop)
150 else:
151 number_of_runs_bootstop = ''
152 if options.number_of_runs:
153 number_of_runs_opt = "-N %d" % options.number_of_runs
154 cmd.append(number_of_runs_opt)
155 else:
156 number_of_runs_opt = 0
157 # (-a)
158 if options.weightfile:
159 weightfile = "-a %s" % options.weightfile
160 cmd.append(weightfile)
161 # (-A)
162 if options.secondary_structure_model:
163 secondary_structure_model = "-A %s" % options.secondary_structure_model
164 cmd.append(secondary_structure_model )
165 # (-b)
166 if options.bootseed:
167 bootseed = "-b %d" % options.bootseed
168 cmd.append(bootseed)
169 else:
170 bootseed = 0
171 # -C - doesn't work in pthreads version, skipped
172 if options.search_complete_random_tree:
173 cmd.append("-d")
174 if options.ml_search_convergence:
175 cmd.append("-D" )
176 if options.model_opt_precision:
177 model_opt_precision = "-e %f" % options.model_opt_precision
178 cmd.append(model_opt_precision)
179 if options.excludefile:
180 excludefile = "-E %s" % options.excludefile
181 cmd.append(excludefile)
182 if options.search_algorithm:
183 search_algorithm = "-f %s" % options.search_algorithm
184 cmd.append(search_algorithm)
185 if options.save_memory_cat_model:
186 cmd.append("-F")
187 if options.groupingfile:
188 groupingfile = "-g %s" % options.groupingfile
189 cmd.append(groupingfile)
190 if options.enable_evol_heuristics:
191 enable_evol_heuristics = "-G %f" % options.enable_evol_heuristics
192 cmd.append(enable_evol_heuristics )
193 if options.initial_rearrangement_setting:
194 initial_rearrangement_setting = "-i %s" % options.initial_rearrangement_setting
195 cmd.append(initial_rearrangement_setting)
196 if options.posterior_bootstopping_analysis:
197 posterior_bootstopping_analysis = "-I %s" % options.posterior_bootstopping_analysis
198 cmd.append(posterior_bootstopping_analysis)
199 if options.majority_rule_consensus:
200 majority_rule_consensus = "-J %s" % options.majority_rule_consensus
201 cmd.append(majority_rule_consensus)
202 if options.print_branch_lengths:
203 cmd.append("-k")
204 if options.multistate_sub_model:
205 multistate_sub_model = "-K %s" % options.multistate_sub_model
206 cmd.append(multistate_sub_model)
207 if options.estimate_individual_branch_lengths:
208 cmd.append("-M")
209 if options.outgroup_name:
210 outgroup_name = "-o %s" % options.outgroup_name
211 cmd.append(outgroup_name)
212 if options.disable_undetermined_seq_check:
213 cmd.append("-O")
214 if options.random_seed:
215 random_seed = "-p %d" % options.random_seed
216 cmd.append(random_seed)
217 multiple_model = None
218 if options.multiple_model:
219 multiple_model = "-q %s" % options.multiple_model
220 cmd.append(multiple_model)
221 if options.constraint_file:
222 constraint_file = "-r %s" % options.constraint_file
223 cmd.append(constraint_file)
224 if options.bin_model_parameter_file:
225 bin_model_parameter_file_name = "RAxML_binaryModelParameters.galaxy"
226 os.symlink(options.bin_model_parameter_file, bin_model_parameter_file_name )
227 bin_model_parameter_file = "-R %s" % options.bin_model_parameter_file
228 #Needs testing. Is the hardcoded name or the real path needed?
229 cmd.append(bin_model_parameter_file)
230 if options.secondary_structure_file:
231 secondary_structure_file = "-S %s" % options.secondary_structure_file
232 cmd.append(secondary_structure_file)
233 if options.starting_tree:
234 starting_tree = "-t %s" % options.starting_tree
235 cmd.append(starting_tree)
236 if options.use_median_approximation:
237 cmd.append("-u")
238 if options.save_memory_gappy_alignments:
239 cmd.append("-U")
240 if options.disable_rate_heterogeneity:
241 cmd.append("-V")
242 if options.sliding_window_size:
243 sliding_window_size = "-W %d" % options.sliding_window_size
244 cmd.append(sliding_window_size)
245 if options.rapid_bootstrap_random_seed:
246 rapid_bootstrap_random_seed = "-x %d" % options.rapid_bootstrap_random_seed
247 cmd.append(rapid_bootstrap_random_seed)
248 else:
249 rapid_bootstrap_random_seed = 0
250 if options.parsimony_starting_tree_only:
251 cmd.append("-y")
252 if options.file_multiple_trees:
253 file_multiple_trees = "-z %s" % options.file_multiple_trees
254 cmd.append(file_multiple_trees)
255
256 print "cmd list: ", cmd, "\n"
257
258 full_cmd = " ".join(cmd)
259 print "Command string: %s" % full_cmd
260
261 try:
262 proc = subprocess.Popen(args=full_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
263 except Exception, err:
264 sys.stderr.write("Error invoking command: \n%s\n\n%s\n" % (cmd, err))
265 sys.exit(1)
266 stdout, stderr = proc.communicate()
267 return_code = proc.returncode
268 if return_code:
269 sys.stdout.write(stdout)
270 sys.stderr.write(stderr)
271 sys.stderr.write("Return error code %i from command:\n" % return_code)
272 sys.stderr.write("%s\n" % cmd)
273 else:
274 sys.stdout.write(stdout)
275 sys.stdout.write(stderr)
276
277 #Multiple runs - concatenate
278 if number_of_runs_opt > 0:
279 if (bootseed == 0) and (rapid_bootstrap_random_seed == 0 ):
280 runfiles = glob.glob('RAxML*RUN*')
281 runfiles.sort(key=getint)
282 # Logs
283 outfile = open('RAxML_log.galaxy','w')
284 for filename in runfiles:
285 if fnmatch.fnmatch(filename, 'RAxML_log.galaxy.RUN.*'):
286 infile = open(filename, 'r')
287 filename_line = "%s\n" % filename
288 outfile.write(filename_line)
289 for line in infile:
290 outfile.write(line)
291 infile.close()
292 outfile.close()
293 # Parsimony Trees
294 outfile = open('RAxML_parsimonyTree.galaxy','w')
295 for filename in runfiles:
296 if fnmatch.fnmatch(filename, 'RAxML_parsimonyTree.galaxy.RUN.*'):
297 infile = open(filename, 'r')
298 filename_line = "%s\n" % filename
299 outfile.write(filename_line)
300 for line in infile:
301 outfile.write(line)
302 infile.close()
303 outfile.close()
304 # Results
305 outfile = open('RAxML_result.galaxy','w')
306 for filename in runfiles:
307 if fnmatch.fnmatch(filename, 'RAxML_result.galaxy.RUN.*'):
308 infile = open(filename, 'r')
309 filename_line = "%s\n" % filename
310 outfile.write(filename_line)
311 for line in infile:
312 outfile.write(line)
313 infile.close()
314 outfile.close()
315 # Multiple Model Partition Files
316 if multiple_model:
317 files = glob.glob('RAxML_bestTree.galaxy.PARTITION.*')
318 if len(files) > 0:
319 files.sort(key=getint)
320 outfile = open('RAxML_bestTreePartitions.galaxy','w')
321 # Best Tree Partitions
322 for filename in files:
323 if fnmatch.fnmatch(filename, 'RAxML_bestTree.galaxy.PARTITION.*'):
324 infile = open(filename, 'r')
325 filename_line = "%s\n" % filename
326 outfile.write(filename_line)
327 for line in infile:
328 outfile.write(line)
329 infile.close()
330 outfile.close()
331 else:
332 outfile = open('RAxML_bestTreePartitions.galaxy','w')
333 outfile.write("No partition files were produced.\n")
334 outfile.close()
335
336 # Result Partitions
337 files = glob.glob('RAxML_result.galaxy.PARTITION.*')
338 if len(files) > 0:
339 files.sort(key=getint)
340 outfile = open('RAxML_resultPartitions.galaxy','w')
341 for filename in files:
342 if fnmatch.fnmatch(filename, 'RAxML_result.galaxy.PARTITION.*'):
343 infile = open(filename, 'r')
344 filename_line = "%s\n" % filename
345 outfile.write(filename_line)
346 for line in infile:
347 outfile.write(line)
348 infile.close()
349 outfile.close()
350 else:
351 outfile = open('RAxML_resultPartitions.galaxy','w')
352 outfile.write("No partition files were produced.\n")
353 outfile.close()
354
355 # DEBUG options
356 infof = open('RAxML_info.galaxy','a')
357 infof.write('\nOM: CLI options DEBUG START:\n')
358 infof.write(options.__repr__())
359 infof.write('\nOM: CLI options DEBUG END\n')
360
361 if __name__=="__main__": __main__()