[Bio] / FigKernelScripts / fig_net.pl Repository:
ViewVC logotype

Annotation of /FigKernelScripts/fig_net.pl

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.3 - (view) (download) (as text)

1 : efrank 1.1 # -*- perl -*-
2 : olson 1.3 #
3 :     # Copyright (c) 2003-2006 University of Chicago and Fellowship
4 :     # for Interpretations of Genomes. All Rights Reserved.
5 :     #
6 :     # This file is part of the SEED Toolkit.
7 :     #
8 :     # The SEED Toolkit is free software. You can redistribute
9 :     # it and/or modify it under the terms of the SEED Toolkit
10 :     # Public License.
11 :     #
12 :     # You should have received a copy of the SEED Toolkit Public License
13 :     # along with this program; if not write to the University of Chicago
14 :     # at info@ci.uchicago.edu or the Fellowship for Interpretation of
15 :     # Genomes at veronika@thefig.info or download a copy from
16 :     # http://www.theseed.org/LICENSE.TXT.
17 :     #
18 :    
19 : efrank 1.1 use Carp;
20 :     use Data::Dumper;
21 :     use Time::HiRes qw(gettimeofday);
22 :    
23 :     use FIGnet;
24 :     use FIG;
25 : mkubal 1.2 use Blast;
26 : efrank 1.1
27 :     my($user);
28 :    
29 : mkubal 1.2 my $usage = "usage: fig_net $url [-echo] [-time] [command]";
30 : efrank 1.1
31 :     defined($url = shift @ARGV)
32 : mkubal 1.2 || die $usage;
33 : efrank 1.1
34 :     $figN = new FIGnet($url);
35 :     $fig = new FIG;
36 :    
37 :     $echo = 0;
38 :     $time_cmds = 0;
39 :     while ((@ARGV > 0) && ($ARGV[0] =~ /^-/))
40 :     {
41 :     $arg = shift @ARGV;
42 :     if ($arg =~ /^-time/i) { $time_cmds = 1 }
43 :     if ($arg =~ /^-echo/i) { $echo = 1 }
44 :     }
45 :    
46 : mkubal 1.2 my($t1,$t2,$i);
47 : efrank 1.1 if (@ARGV > 0) { $req = join( " ", @ARGV ); }
48 :     while ( (defined($req) && $req) || ($req = &get_req) )
49 :     {
50 :     if ($time_cmds)
51 :     {
52 :     $t1 = gettimeofday;
53 :     }
54 :    
55 : mkubal 1.2 if ($req =~ /^\s*DB\s*$/)
56 :     {
57 :     if ($figN->{_fig}) # if a local SEED
58 :     {
59 :     print "$FIG_Config::db\n\n";
60 :     }
61 :     else
62 :     {
63 :     my $url = $figN->{_url} . "/kernel.cgi?request=DB";
64 :     my @out = &FIGnet::get_url($url);
65 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
66 :     print $out[$i+1];
67 :     }
68 :     }
69 :     elsif ($req =~ /^\s*abbrev\s+(\S.*\S)\s*$/)
70 :     {
71 :     $genome_name = $1;
72 :     print &FIGnet::abbrev($genome_name),"\n";;
73 :     }
74 :     elsif ($req =~ /^\s*genomes(\s+(\S.*\S))?\s*$/)
75 : efrank 1.1 {
76 :     $pat = $2;
77 :     foreach $genome ($figN->genomes)
78 :     {
79 : mkubal 1.2 my $genus_species = $figN->genus_species($genome);
80 : efrank 1.1 if ((! $pat) || ($genus_species =~ /$pat/))
81 :     {
82 :     print join("\t",(&padded($genome,15),$genus_species)),"\n";
83 :     }
84 :     }
85 :     print "\n";
86 :     }
87 :     elsif ($req =~ /^\s*map_to_ecs\s+(\S+)\s*$/)
88 :     {
89 :     print join("\n",$figN->map_to_ecs($1)),"\n\n";
90 :     }
91 :     elsif ($req =~ /^\s*all_maps\s*$/)
92 :     {
93 :     @maps = $figN->all_maps;
94 :     foreach $map (@maps)
95 :     {
96 :     print "$map: ",$fig->map_name($map),"\n";
97 :     }
98 :     print "\n";
99 :     }
100 :     elsif ($req =~ /^\s*all_compounds\s*$/)
101 :     {
102 :     @compounds = $figN->all_compounds;
103 :     foreach $compound (@compounds)
104 :     {
105 :     my @tmp = $fig->names_of_compound($compound);
106 :     print "$compound: $tmp[0]\n";
107 :     }
108 :     print "\n";
109 :     }
110 :     elsif ($req =~ /^\s*all_reactions\s*$/)
111 :     {
112 :     @reactions = $figN->all_reactions;
113 :     foreach $reaction (@reactions)
114 :     {
115 :     $tmp = $fig->displayable_reaction($reaction);
116 :     print "$tmp\n";
117 :     }
118 :     print "\n";
119 :     }
120 :     elsif ($req =~ /^\s*reversible\s+(\S+)\s*$/)
121 :     {
122 :     $rid = $1;
123 :     $rev = $figN->reversible($rid) ? "reversible" : "not reversible";;
124 :     $displayable = $fig->displayable_reaction($rid);
125 :     print "$rev\n$displayable\n\n";
126 :     }
127 :     elsif ($req =~ /^\s*catalyzed_by\s+(\S+)\s*$/)
128 :     {
129 :     $rid = $1;
130 :     @ecs = $figN->catalyzed_by($rid);
131 :     $displayable = $fig->displayable_reaction($rid);
132 :     print "$displayable\n";
133 :     foreach $ec (@ecs)
134 :     {
135 :     $x = $fig->expand_ec($ec);
136 :     print "$x\n";
137 :     }
138 :     print "\n";
139 :     }
140 :     elsif ($req =~ /^\s*catalyzes\s+(\S+)\s*$/)
141 :     {
142 :     $ec = $1;
143 :     @rids = $figN->catalyzes($ec);
144 :     print $fig->expand_ec($ec),"\n";
145 :     foreach $rid (@rids)
146 :     {
147 :     $displayable = $fig->displayable_reaction($rid);
148 :     print "$displayable\n";
149 :     }
150 :     print "\n";
151 :     }
152 :     elsif ($req =~ /^\s*reaction2comp\s+(\S+)\s+(\d)\s*$/)
153 :     {
154 :     $rid = $1;
155 :     $which = $2;
156 :     @tmp = $figN->reaction2comp($rid,$which);
157 :     print &Dumper(\@tmp);
158 :     $displayable = $fig->displayable_reaction($rid);
159 :     print "$displayable\n\n";
160 :     }
161 :     elsif ($req =~ /^\s*names_of_compound\s+(\S+)\s*$/)
162 :     {
163 :     $cid = $1;
164 :     @names = $figN->names_of_compound($cid);
165 :     foreach $name (@names)
166 :     {
167 :     print "$name\n";
168 :     }
169 :     }
170 :     elsif ($req =~ /^\s*comp2react\s+(\S+)\s*$/)
171 :     {
172 :     $cid = $1;
173 :     @rids = $figN->comp2react($cid);
174 :     foreach $rid (@rids)
175 :     {
176 :     print $fig->displayable_reaction($rid),"\n";
177 :     }
178 :     }
179 :     elsif ($req =~ /^\s*names_of_compounds\s*$/)
180 :     {
181 :     foreach $x ($figN->names_of_compounds)
182 :     {
183 :     ($cid,$names) = @$x;
184 :     print "$cid\n";
185 :     foreach $name (@$names)
186 :     {
187 :     print "\t$name\n";
188 :     }
189 :     print "\n";
190 :     }
191 :     }
192 :     elsif ($req =~ /^\s*seqs_with_roles_in_genomes\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
193 :     {
194 :     $genomesF = $1;
195 :     $rolesF = $2;
196 :     $who = $3;
197 :     $genomes = [map { chop; $_ } `cat $genomesF`];
198 :     $roles = [map { chop; $_ } `cat $rolesF`];
199 :     print "\n";
200 :     }
201 : mkubal 1.2 elsif ($req =~ /^\s*feature_annotations\s+(\S+)\s*$/)
202 :     {
203 :     $fid = $1;
204 :     print "Annotations of $fid\n\n";
205 :     @annotations = $figN->feature_annotations($fid);
206 :     foreach $x (@annotations)
207 :     {
208 :     (undef,$ts,$who,$annotation) = @$x;
209 :     print "$ts\t$who\n$annotation\n============\n";
210 :     }
211 :     print "\n";
212 :     }
213 :     elsif ($req =~ /^\s*dna_seq\s+(\S+)\s+(\S+)\s*$/)
214 :     {
215 :     $seq = $figN->dna_seq($1,split(/,/,$2));
216 :     print "$seq\n\n";
217 :     }
218 :     elsif ($req =~ /^\s*all_protein_families\s*$/)
219 :     {
220 :     print "Fam.\tSize\n\n";
221 :     foreach $family ($figN->all_protein_families)
222 :     {
223 :     print "$family\t",$figN->sz_family($family),"\n";
224 :     }
225 :     print "\n";
226 :     }
227 :     #elsif ($req =~ /^\s*all_features\s+(\d+\.\d+)\s+(\S+)\s*$/)
228 :     #{
229 :     # @ids = sort { $figN->by_fig_id($a,$b) } $figN->all_features($1,$2);
230 :     # while (@ids > 0)
231 :     # {
232 :     # @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
233 :     # print join("\t",@tmp),"\n";
234 :     # }
235 :     # print "\n";
236 :     # }
237 :     elsif ($req =~ /^\s*all_sets\s+(\S+)\s+(\S+)\s*$/)
238 :     {
239 :     $relation = $1;
240 :     $set_name = $2;
241 :     print "Set\tSize\n\n";
242 :     foreach $set ($figN->all_sets($relation,$set_name))
243 :     {
244 :     print "$set\t",$figN->sz_set($set,$relation,$set_name),"\n";
245 :     }
246 :     print "\n";
247 :     }
248 :     elsif ($req =~ /^\s*catalyzed_by\s+(\S+)\s*$/)
249 :     {
250 :     $rid = $1;
251 :     @ecs = $fig->catalyzed_by($rid);
252 :     $displayable = $figN->displayable_reaction($rid);
253 :     print "$displayable\n";
254 :     foreach $ec (@ecs)
255 :     {
256 :     $x = $fig->expand_ec($ec);
257 :     print "$x\n";
258 :     }
259 :     print "\n";
260 :     }
261 :    
262 :     elsif ($req =~ /^\s*cgi_url\s*$/)
263 :     {
264 :     print $figN->cgi_url;
265 :    
266 :     }
267 :    
268 :     elsif ($req =~ /^\s*get_translation\s+(\S+)\s*$/)
269 :     {
270 :     $id = $1;
271 :     $seq = $figN->get_translation($id);
272 :     print "$seq\n";
273 :     print "\n";
274 :     }
275 :    
276 :     elsif ($req =~ /^\s*function_of\s+(\S+)(\s+(\S+))?\s*$/)
277 :     {
278 :     if ($2)
279 :     {
280 :     $extra = $2;
281 :     $all = ($extra =~ /all/i);
282 :     $tran = ($extra =~ /tran/i);
283 :     }
284 :     if ($all)
285 :     {
286 :     foreach $x ($figN->function_of($1))
287 :     {
288 :     ($who,$func) = @$x;
289 :     if ($tran) { $func = $figN->translate_function($func) }
290 :     print &padded($who,30)," $func\n";
291 :     }
292 :     }
293 :     else
294 :     {
295 :     $func = $figN->function_of($1);
296 :     if ($tran) { $func = $figN->translate_function($func) }
297 :     print "$func\n";
298 :     }
299 :     print "\n";
300 :     }
301 :     elsif ($req =~ /^\s*org_of\s+(\S+)\s*$/)
302 :     {
303 :     print $figN->org_of($1),"\n\n";
304 :     }
305 :    
306 :     elsif ($req =~ /^\s*blast\s+(\S+)\s*$/)
307 :     {
308 :     $id = $1;
309 :     $func = $figN->function_of($id);
310 :    
311 :     if ($sims = &Blast::blastp([[$id,$figN->get_translation($id)]],"$FIG_Config::global/nr","-e 1.0e-5",0,0))
312 :     {
313 :     $sims = $sims->{$id};
314 :    
315 :     print &padded($id,20),"\t",$sims->[0]->ln1."\t$func\n\n";
316 :     foreach $sim (@$sims)
317 :     {
318 :     $func = $figN->function_of($sim->id2);
319 :     $org = $figN->org_of($sim->id2);
320 :     print join("\t",(&padded($sim->id2,20),
321 :     $sim->ln2,
322 :     $sim->psc,
323 :     $sim->b1,
324 :     $sim->e1,
325 :     $sim->b2,
326 :     $sim->e2,
327 :     $org,
328 :     $func)),"\n";
329 :     }
330 :     }
331 :     print "\n";
332 :     }
333 :    
334 :     elsif ($req =~ /^\s*by_alias\s+(\S+)\s*$/)
335 :     {
336 :     $alias = $1;
337 :     print $figN->by_alias($alias);
338 :     }
339 :     elsif ($req =~ /^\s*by_fig_id\s+(\S+)\s+(\S+)\s*$/)
340 :     {
341 :     $feature_id_a = $1;
342 :     $feature_id_b = $2;
343 :     print $figN->by_fig_id($feature_id_a,$feature_id_b),"\n";
344 :     }
345 :     elsif ($req =~ /^\s*cas\s+(\S+)\s*$/)
346 :     {
347 :     $cid = $1;
348 :     $cas = $figN->cas($cid);
349 :     @names = $figN->names_of_compound($cid);
350 :     print "$cid\t$cas\t$names[0]\n\n";
351 :     }
352 :     elsif ($req =~ /^\s*cas_to_cid\s+(\S+)\s*$/)
353 :     {
354 :     $cas = $1;
355 :     $cid = $figN->cas_to_cid($cas);
356 :     print "$cid\n\n";
357 :     }
358 :     elsif ($req =~ /^\s*close_genes\s+(\S+)\s+(\S+)\s*$/)
359 :     {
360 :     $feature_id = $1;
361 :     $dist = $2;
362 :     print join(",",$figN->close_genes($feature_id,$dist)),"\n";
363 :     }
364 :     elsif ($req =~ /^\s*contig_ln\s+(\S+)\s+(\S+)\s*$/)
365 :     {
366 :     print $figN->contig_ln($1,$2),"\n\n";
367 :     }
368 :     elsif ($req =~ /^\s*coupling_and_evidence\s+(fig\|\d+\.\d+\.peg\.\d+)\s+(\d+)\s+(\S+)\s+(\S+)/)
369 :     {
370 :     $fid = $1;
371 :     $bound = $2;
372 :     $sim_cutoff = $3;
373 :     $coup_cutoff = $4;
374 :     @tmp = $figN->coupling_and_evidence($fid,$bound,$sim_cutoff,$coup_cutoff);
375 :     print &Dumper(\@tmp),"\n\n";
376 :     }
377 :    
378 :     elsif ($req =~ /^\s*crude_estimate_of_distance\s+(\S+)\s+(\S+)\s*$/)
379 :     {
380 :     print $figN->crude_estimate_of_distance($1,$2),"\n\n";
381 :     }
382 :     elsif ($req =~ /^\s*displayable_reaction\s+(\S+)\s*$/)
383 :     {
384 :     $rid = $1;
385 :     print $figN->displayable_reaction($rid),"\n";
386 :     }
387 :     elsif ($req =~ /^\s*ec_to_maps\s+(\S+)\s*$/)
388 :     {
389 :     print join("\n",$figN->ec_to_maps($1)),"\n\n";
390 :     }
391 :     elsif ($req =~ /^\s*map_name\s+(\S+)\s*$/)
392 :     {
393 :     print $figN->map_name($1),"\n\n";
394 :     }
395 :     elsif ($req =~ /^\s*verify_dir\s+(\S+)\s*$/)
396 :     {
397 :     $dir = $1;
398 :     $figN->verify_dir($dir);
399 :     print "$dir is now a directory\n";
400 :     }
401 :     elsif ($req =~ /^\s*ec_name\s+(\S+)\s*$/)
402 :     {
403 :     $ec= $1;
404 :     print $figN->ec_name($ec),"\n";
405 :     }
406 :     elsif ($req =~ /^\s*all_roles\s*$/)
407 :     {
408 :     my @tmp = $figN->all_roles;
409 :     print &Dumper(\@tmp);
410 :     }
411 :    
412 :     elsif ($req =~ /^\s*expand_ec\s+(\S+)\s*$/)
413 :     {
414 :     $ec = $1;
415 :     print $figN->expand_ec($ec),"\n";
416 :     }
417 :     elsif ($req =~ /^\s*clean_tmp\s*$/)
418 :     {
419 :     $figN->clean_tmp;
420 :     print "Cleaned $FIG_Config::temp\n";
421 :     }
422 :     elsif ($req =~ /^\s*ftype\s+(\S+)\s*$/)
423 :     {
424 :     $feature_id = $1;
425 :     print $figN->ftype($feature_id),"\n";;
426 :     }
427 :     elsif ($req =~ /^\s*genome_of\s+(\S+)\s*$/)
428 :     {
429 :     $feature_id = $1;
430 :     print $figN->genome_of($feature_id),"\n";
431 :     }
432 :     elsif ($req =~ /^\s*pegs_of\s+(\S+)\s*$/)
433 :     {
434 :     $genome = $1;
435 :     print join(",",$figN->pegs_of($genome)),"\n";
436 :     }
437 :     elsif ($req =~ /^\s*rnas_of\s+(\S+)\s*$/)
438 :     {
439 :     $genome = $1;
440 :     my @tmp = $figN->rnas_of($genome);
441 :     print &Dumper(\@tmp);
442 :     }
443 :     elsif ($req =~ /^\s*feature_aliases\s+(\S+)\s*$/)
444 :     {
445 :     $feature_id = $1;
446 :     print join(",",$figN->feature_aliases($feature_id)),"\n";
447 :     }
448 :     elsif ($req =~ /^\s*possibly_truncated\s+(\S+)\s*$/)
449 :     {
450 :     $feature_id = $1;
451 :     print $figN->possibly_truncated($feature_id),"\n";
452 :     }
453 :     elsif ($req =~ /^\s*is_real_feature\s+(\S+)\s*$/)
454 :     {
455 :     $feature_id = $1;
456 :     print $figN->is_real_feature($feature_id),"\n";
457 :     }
458 :     elsif ($req =~ /^\s*translatable\s+(\S+)\s*$/)
459 :     {
460 :     $prot_id = $1;
461 :     print $figN->translatable($prot_id),"\n";
462 :     }
463 :     elsif ($req =~ /^\s*maps_to_id\s+(\S+)\s*$/)
464 :     {
465 :     $id = $1;
466 :     print $figN->maps_to_id($id),"\n";
467 :     }
468 :     elsif ($req =~ /^\s*translated_function_of\s+(\S+)\s+(\S+)\s*$/)
469 :     {
470 :     $peg = $1;
471 :     $user = $2;
472 :     print $figN->translated_function_of($peg,$user),"\n";
473 :     }
474 :     elsif ($req =~ /^\s*translate_function\s+(\S.*\S)\s*$/)
475 :     {
476 :     $func = $1;
477 :     print $figN->translate_function($func),"\n";
478 :     }
479 :     elsif ($req =~ /^\s*hypo\s+(\S.*\S)\s*$/)
480 :     {
481 :     print $figN->hypo($1),"\n";
482 :     }
483 :     elsif ($req =~ /^\s*blastit\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
484 :     {
485 :     $peg = $1;
486 :     $seq = $2;
487 :     $db = $3;
488 :     $maxP = $4;
489 :     @tmp = $figN->blastit($peg,$seq,$db,$maxP);
490 :     print &Dumper(\@tmp);
491 :     }
492 :     elsif ($req =~ /^\s*related_by_func_sim\s+(\S+)\s+(\S+)\s*$/)
493 :     {
494 :     $peg = $1;
495 :     $user = $2;
496 :     print join(",",$figN->related_by_func_sim($peg,$user)),"\n";
497 :     }
498 :     elsif ($req =~ /^\s*epoch_to_readable\s*$/)
499 :     {
500 :     print $figN->epoch_to_readable(time);
501 :     }
502 :     elsif ($req =~ /^\s*search_index\s+(\S+)\s*$/)
503 :     {
504 :     $pattern = $1;
505 :     my @tmp = $figN->search_index($pattern);
506 :     print &Dumper(\@tmp);
507 :     }
508 :     elsif ($req =~ /^\s*sz_family\s+(\S+)\s*$/)
509 :     {
510 :     $family = $1;
511 :     print $figN->sz_family($family),"\n";
512 :     }
513 :     elsif ($req =~ /^\names_of_compound\s+(\S+)\s*$/)
514 :     {
515 :     my @tmp = $figN->names_of_compound($1);
516 :     print &Dumper(\@tmp);
517 :     }
518 :     elsif ($req =~ /^\s*reversible\s+(\S+)\s*$/)
519 :     {
520 :     $rid = $1;
521 :     print $figN->reversible($rid),"\n";
522 :     }
523 :     elsif ($req =~ /^\s*neighborhood_of_role\s+(\S+)\s*$/)
524 :     {
525 :     $role = $1;
526 :     my @tmp = $figN->neighborhood_of_role($role);
527 :     print &Dumper(\@tmp);
528 :     }
529 :     elsif ($req =~ /^\s*roles_of_function\s+(\S+)\s*$/)
530 :     {
531 :     $func = $1;
532 :     my @tmp = $figN->roles_of_function($func);
533 :     print &Dumper(\@tmp);
534 :     }
535 :     elsif ($req =~ /^\s*assign_function\s+(\S+)\s+(\S+)(\s+conf=(\S))?\s+(\S.*\S)\s*$/)
536 :     {
537 :     $peg = $1;
538 :     $user = $2;
539 :     $conf = $3 ? $4 : "";
540 :     $func = $5;
541 :     print $figN->assign_function($peg,$user,$func,$conf),"\n\n";
542 :     }
543 :     elsif ($req =~ /^\s*assign_functionF\s+(\S+)\s+(\S+)\s*$/)
544 :     {
545 :     $user = $1;
546 :     $file = $2;
547 :     if (open(TMP,"<$file"))
548 :     {
549 :     while (defined($_ = <TMP>))
550 :     {
551 :     chop;
552 :     ($peg,$func,$conf) = split(/\t/,$_);
553 :     if (! $conf) { $conf = "" }
554 :     if ($user =~ /master:(.*)/)
555 :     {
556 :     $userR = $1;
557 :     $funcO = $figN->function_of($peg);
558 :     if ($funcO ne $func)
559 :     {
560 :     $figN->assign_function($peg,"master",$func,$conf);
561 :     $figN->add_annotation($peg,$userR,"Set master function to\n$func\n");
562 :     }
563 :     }
564 :     else
565 :     {
566 :     $funcO = $figN->function_of($peg,$user);
567 :     if ($funcO ne $func)
568 :     {
569 :     $figN->assign_function($peg,$user,$func,$conf);
570 :     $figN->add_annotation($peg,$user,"Set function to\n$func\n");
571 :     }
572 :     }
573 :     }
574 :     close(TMP);
575 :     }
576 :     }
577 :    
578 :     elsif ($req =~ /^\s*largest_clusters\s+(\S+)\s+(\S+)\s*$/)
579 :     {
580 :     $file = $1;
581 :     $user = $2;
582 :     my @tmp = `cat $file`;
583 :     chop @tmp;;
584 :     my @tmp1 = $figN->largest_clusters(\@tmp,$user);
585 :     print &Dumper(\@tmp1);
586 :     }
587 :     elsif ($req =~ /^\s*unique_functions\s+(\S+)\s+(\S+)\s*$/)
588 :     {
589 :     $pegs = $1;
590 :     $user = $2;
591 :     my @tmp = $figN->unique_functions([split(/,/,$pegs)],$user);
592 :     print &Dumper(\@tmp);
593 :     }
594 :     elsif ($req =~ /^\s*extract_seq\s+(\S+)\s+(\S+)\s*$/)
595 :     {
596 :     $contigsF = $1;
597 :     $loc = $2;
598 :     $contigs = &load_contigs($contigsF);
599 :     print &Dumper(&FIG::extract_seq($contigs,$loc));
600 :     }
601 :     elsif ($req =~ /^\s*is_bacterial\s+(\S+)\s*$/)
602 :     {
603 :     $genome = $1;
604 :     print $figN->is_bacterial($genome),"\n";;
605 :     }
606 :     elsif ($req =~ /^\s*is_archaeal\s+(\S+)\s*$/)
607 :     {
608 :     $genome = $1;
609 :     print $figN->is_archaeal($genome),"\n";
610 :     }
611 :     elsif ($req =~ /^\s*is_prokaryotic\s+(\S+)\s*$/)
612 :     {
613 :     $genome = $1;
614 :     print $figN->is_prokaryotic($genome),"\n";
615 :     }
616 :     elsif ($req =~ /^\s*is_eukaryotic\s+(\S+)\s*$/)
617 :     {
618 :     $genome = $1;
619 :     print $figN->is_eukaryotic($genome),"\n";
620 :     }
621 :     elsif ($req =~ /^\s*sort_genomes_by_taxonomy\s+(\S+(\s+\S+)*)\s*$/)
622 :     {
623 :     @list_of_genomes = split(/\s+/,$1);
624 :     print join(",",$figN->sort_genomes_by_taxonomy(@list_of_genomes)),"\n";
625 :     }
626 :     elsif ($req =~ /^\s*sort_fids_by_taxonomy\s+(\S+(\s+\S+)*)\s*$/)
627 :     {
628 :     @fids = split(/\s+/,$1);
629 :     print join(",",$figN->sort_fids_by_taxonomy(@fids)),"\n";
630 :     }
631 :     elsif ($req =~ /^\s*build_tree_of_complete\s+(\S+)\s*$/)
632 :     {
633 :     $min_for_label = $1;
634 :     print &Dumper($figN->build_tree_of_complete($min_for_label));
635 :     }
636 :     elsif ($req =~ /^\s*taxonomic_groups_of_complete\s+(\S+)\s*$/)
637 :     {
638 :     $min_for_labels = $1;
639 :     print &Dumper($figN->taxonomic_groups_of_complete($min_for_labels));
640 :     }
641 :     elsif ($req =~ /^\s*max\s+(((\d+)\s+)*\d+)\s*$/)
642 :     {
643 :     print $figN->max(split(/\s+/,$1)),"\n\n";
644 :     }
645 :     elsif ($req =~ /^\s*add_genome\s+((.*\/)?(\d+\.\d+))\s*$/)
646 :     {
647 :     $genomeF = $1;
648 :     $genome = $3;
649 :     if ((! -d "$FIG_Config::organisms/$genome") && ($figN->add_genome($genomeF)))
650 :     {
651 :     print "Added $genome\n";
652 :     }
653 :     else
654 :     {
655 :     print "Failed to add $genome from $genomeF\n";
656 :     }
657 :     }
658 :     elsif ($req =~ /^\s*delete_genomes\s+(\d.*\d)\s*$/)
659 :     {
660 :     $genomes = $1;
661 :     @genomes = split(/\s+/,$genomes);
662 :     if (@genomes > 0)
663 :     {
664 :     @bad_genomes = grep { ! -d "$FIG_Config::organisms/$_" } @genomes;
665 :     if (@bad_genomes > 0)
666 :     {
667 :     print "Bad Genomes: ",join(" ",@bad_genomes),"\n";
668 :     }
669 :     else
670 :     {
671 :     $figN->delete_genomes(\@genomes);
672 :     print "Completed deleting ",join(" ",@genomes),"\n";
673 :     }
674 :     }
675 :     }
676 :     elsif ($req =~ /^\s*min\s+(((\d+)\s+)*\d+)\s*$/)
677 :     {
678 :     print $figN->min(split(/\s+/,$1)),"\n\n";
679 :     }
680 :     elsif ($req =~ /^\s*between\s+(\d+)\s+(\d+)\s+(\d+)\s*$/)
681 :     {
682 :     print $figN->between($1,$2,$3),"\n\n";
683 :     }
684 :     elsif ($req =~ /^\s*merge_related_annotations\s+(\S.*\S)\s*$/)
685 :     {
686 :     $pegs = [split(/\s+/,$1)];
687 :     my @tmp = $figN->merged_related_annotations($pegs);
688 :     print &Dumper(\@tmp);
689 :     print "\n";
690 :     }
691 :     elsif ($req =~ /^\s*genus_species\s+(\d+\.\d+)\s*$/)
692 :     {
693 :     print $figN->genus_species($1),"\n\n";
694 :     }
695 :     elsif ($req =~ /^\s*genome_counts(\s+(complete))?/)
696 :     {
697 :     $counts = $figN->genome_counts($2);
698 :     print "$counts\n";
699 :     }
700 :     elsif ($req =~ /^\s*file2N\s+(\S+)\s*$/)
701 :     {
702 :     print $figN->file2N($1),"\n\n";
703 :     }
704 :     elsif ($req =~ /^\s*genome_version\s+(\S+)\s*$/)
705 :     {
706 :     $_ = defined($_ = $figN->genome_version($1)) ? $_ : "undefined";
707 :     print "$_\n\n";
708 :     }
709 :    
710 :     elsif ($req =~ /^\s*taxonomy_of\s+(\d+\.\d+)\s*$/)
711 :     {
712 :     print $figN->taxonomy_of($1),"\n\n";
713 :     }
714 :    
715 :     elsif ($req =~ /^\s*fast_coupling\s+(fig\|\d+\.\d+\.peg\.\d+)\s+(\d+)\s+(\S+)/)
716 :     {
717 :     $fid = $1;
718 :     $bound = $2;
719 :     $coup_cutoff = $3;
720 :     @tmp = $figN->fast_coupling($fid,$bound,$coup_cutoff);
721 :     print &Dumper(\@tmp),"\n\n";
722 :     }
723 :    
724 :     elsif ($req =~ /^\s*auto_assign\s+(fig\|\d+\.\d+\.peg\.\d+)(\s+(\S+))?\s*$/)
725 :     {
726 :     $fid = $1;
727 :     $seq = $3;
728 :     print $figN->auto_assign($fid,$seq),"\n\n";
729 :     }
730 :    
731 :     elsif ($req =~ /^\s*auto_assignG\s+(\S+)\s+(\S.*\S)\s*$/)
732 :     {
733 :     $user = $1;
734 :     @genomes = split(/\s+/,$2);
735 :     foreach $genome (@genomes)
736 :     {
737 :     if (-s "$FIG_Config::organisms/$genome/Features/peg/tbl")
738 :     {
739 :     print STDERR "making assignments for $genome\n";
740 :     system "cut -f1 $FIG_Config::organisms/$genome/Features/peg/tbl > tmp$$ ; fig auto_assignF $user tmp$$";
741 :     unlink("tmp$$");
742 :     }
743 :     }
744 :     print "\n";
745 :     }
746 :    
747 :     elsif (($req =~ /^\s*auto_assignF\s+(\S+)\s+(\S+)\s*$/) &&
748 :     ($file = $2) && (-s $file) &&
749 :     ($user = $1))
750 :     {
751 :     $n = 0;
752 :     foreach $assignment (`cut -f1 $file | auto_assign | make_calls`)
753 :     {
754 :     if ($assignment =~ /^(\S+)\t(\S[^\t]+\S)(\t(\S))?\s*$/)
755 :     {
756 :     $prot = $1;
757 :     $function = $2;
758 :     $conf = $4 ? $4 : "";
759 :     $n++;
760 :     if ($user =~ /master:(.*)/)
761 :     {
762 :     $userR = $1;
763 :     $figN->assign_function($prot,"master",$function,$conf);
764 :     if ($userR ne "none")
765 :     {
766 :     $figN->add_annotation($prot,$userR,"Set master function to\n$function\n");
767 :     }
768 :     }
769 :     else
770 :     {
771 :     $figN->assign_function($prot,$user,$function,$conf);
772 :     if ($user ne "none")
773 :     {
774 :     $figN->add_annotation($prot,$user,"Set function to\n$function\n");
775 :     }
776 :     }
777 :     }
778 :     }
779 :     close(TMP);
780 :     print STDERR "$n assignments made (all attributed to $user)\n";
781 :     }
782 :    
783 :     elsif ($req =~ /^\s*assignments_made\s+(\S+)\s+(\d{1,2}\/\d{1,2}\/\d{4})(\s+(\S.*\S))?\s*$/)
784 :     {
785 :     $who = $1;
786 :     $date = $2;
787 :     if ($3)
788 :     {
789 :     $genomes = [split(/\s+/,$4)];
790 :     }
791 :     else
792 :     {
793 :     $genomes = [$figN->genomes];
794 :     }
795 :    
796 :     foreach $assignment ($figN->assignments_made($genomes,$who,$date))
797 :     {
798 :     print join("\t",@$assignment),"\n";
799 :     }
800 :     }
801 :    
802 :     elsif ($req =~ /^\s*genes_in_region\s+(\d+\.\d+)\s+(\S+)\s+(\d+)\s+(\d+)\s*$/)
803 :     {
804 :     print &Dumper($figN->genes_in_region($1,$2,$3,$4)),"\n\n";
805 :     }
806 :     elsif ($req =~ /^\s*all_features\s+(\d+\.\d+)\s+(\S+)\s*$/)
807 :     {
808 :     @ids = sort { $figN->by_fig_id($a,$b) } $figN->all_features($1,$2);
809 :     while (@ids > 0)
810 :     {
811 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
812 :     print join("\t",@tmp),"\n";
813 :     }
814 :     print "\n";
815 :     }
816 :     elsif ($req =~ /^\s*function_of\s+(\S+)\s*(\S+)?\s*$/)
817 :     {
818 :     if ($2)
819 :     {
820 :     $extra = $2;
821 :     $all = ($extra =~ /all/i);
822 :     $tran = ($extra =~ /tran/i);
823 :     }
824 :     if ($all)
825 :     {
826 :     foreach $x ($figN->function_of($1))
827 :     {
828 :     ($who,$func) = @$x;
829 :     if ($tran) { $func = $figN->translate_function($func) }
830 :     print &padded($who,30)," $func\n";
831 :     }
832 :     }
833 :     else
834 :     {
835 :     $func = $figN->function_of($1);
836 :     if ($tran) { $func = $figN->translate_function($func) }
837 :     print "$func\n";
838 :     }
839 :     print "\n";
840 :     }
841 :     elsif ($req =~ /^\s*in_cluster_with\s+(\S+)\s*$/)
842 :     {
843 :     $peg = $1;
844 :     @pegs = $figN->in_cluster_with($peg);
845 :     $func = $figN->function_of($peg);
846 :     print "$peg\t$func\n\n";
847 :     foreach $peg (@pegs)
848 :     {
849 :     $func = $figN->function_of($peg);
850 :     print "$peg\t$func\n";
851 :     }
852 :     print "\n";
853 :     }
854 :     elsif ($req =~ /^\s*feature_location\s+(\S+)\s*$/)
855 :     {
856 :     $fid = $1;
857 :     if ($loc = $figN->feature_location($fid))
858 :     {
859 :     print "$loc\n";
860 :     }
861 :     else
862 :     {
863 :     print "no location\n";
864 :     }
865 :     }
866 :     elsif ($req =~ /^\s*translation_length\s+(\S+)\s*$/)
867 :     {
868 :     $fid = $1;
869 :     if ($len = $figN->translation_length($fid))
870 :     {
871 :     print "$len\n";
872 :     }
873 :     else
874 :     {
875 :     print "no length for $fid\n";
876 :     }
877 :     }
878 :     elsif ($req =~ /^\s*mapped_prot_ids\s+(\S+)\s*$/)
879 :     {
880 :     foreach $x ($figN->mapped_prot_ids($1))
881 :     {
882 :     ($id,$len) = @$x;
883 :     print &padded($id,20),"\t$len\n";
884 :     }
885 :     print "\n";
886 :     }
887 :     elsif ($req =~ /^\s*boundaries_of\s+(\S+)\s*$/)
888 :     {
889 :     print join("_",$figN->boundaries_of($1)),"\n\n";
890 :     }
891 :     elsif ($req =~ /^\s*family_function\s+(\d+)\s*$/)
892 :     {
893 :     $family = $1;
894 :     $func = $figN->family_function($family);
895 :     print "family $family: $func\n\n";
896 :     }
897 :     elsif ($req =~ /^\s*in_family\s+(\S+)\s*$/)
898 :     {
899 :     $id = $1;
900 :     $n = $figN->in_family($id);
901 :     print "$id is in family $n\n\n";
902 :     }
903 :     elsif ($req =~ /^\s*ids_in_family\s+(\d+)\s*$/)
904 :     {
905 :     $family = $1;
906 :     $func = $figN->family_function($family);
907 :     print "family $family: $func\n\n";
908 :     @ids = $figN->ids_in_family($family);
909 :     while (@ids > 0)
910 :     {
911 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
912 :     print join("\t",@tmp),"\n";
913 :     }
914 :     print "\n";
915 :    
916 :     }
917 :     elsif ($req =~ /^\s*in_sets\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
918 :     {
919 :     $id = $1;
920 :     $relation = $2;
921 :     $set_name = $3;
922 :     print "$id is in set(s) ",join(",",$figN->in_sets($id,$relation,$set_name)),"\n\n";
923 :     }
924 :     elsif ($req =~ /^\s*in_pch_pin_with\s+(\S+)\s*$/)
925 :     {
926 :     $id = $1;
927 :     print "$id is in set(s) ",join(",",$figN->in_pch_pin_with($id)),"\n\n";
928 :     }
929 :     elsif ($req =~ /^\s*exportable_subsystem\s+(\S.*\S+)\s*$/)
930 :     {
931 :     my $ssa = $1;
932 :     my($spreadsheet,$notes) = $figN->exportable_subsystem($ssa);
933 :     print join("",@$spreadsheet),join("",@$notes),"\n";
934 :     }
935 :     elsif ($req =~ /^\s*is_exchangable_subsystem\s+(\S.*\S+)\s*$/)
936 :     {
937 :     my $ssa = $1;
938 :     print $figN->is_exchangable_subsystem($ssa),"\n";
939 :     }
940 :     elsif ($req =~ /^\s*all_exchangable_subsystems\s*$/)
941 :     {
942 :     print join("\n",$figN->all_exchangable_subsystems),"\n";
943 :     }
944 :     elsif ($req =~ /^\s*export_set\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
945 :     {
946 :     $relation = $1;
947 :     $set_name = $2;
948 :     $file = $3;
949 :     print $figN->export_set($relation,$set_name,$file),"\n\n";
950 :     }
951 :     elsif ($req =~ /^\s*export_chromosomal_clusters\s*$/)
952 :     {
953 :     print $figN->export_set("chromosomal_clusters","cluster_id","$FIG_Config::global/chromosomal_clusters"),"\n\n";
954 :     }
955 :     elsif ($req =~ /^\s*export_pch_pins\s*$/)
956 :     {
957 :     print $figN->export_set("pch_pins","pin","$FIG_Config::global/pch_pins"),"\n\n";
958 :     }
959 :     elsif ($req =~ /^\s*add_chromosomal_clusters\s+(\S+)\s*$/)
960 :     {
961 :     $file = $1;
962 :     print $figN->add_chromosomal_clusters($file),"\n\n";
963 :     }
964 :     elsif ($req =~ /^\s*add_pch_pins\s+(\S+)\s*$/)
965 :     {
966 :     $file = $1;
967 :     print $figN->add_pch_pins($file),"\n\n";
968 :     }
969 :     elsif ($req =~ /^\s*all_sets\s+(\S+)\s+(\S+)\s*$/)
970 :     {
971 :     $relation = $1;
972 :     $set_name = $2;
973 :     print "Set\tSize\n\n";
974 :     foreach $set ($figN->all_sets($relation,$set_name))
975 :     {
976 :     print "$set\t",$figN->sz_set($set,$relation,$set_name),"\n";
977 :     }
978 :     print "\n";
979 :     }
980 :     elsif ($req =~ /^\s*seqs_with_role\s+(\S+)\s+(\S+)\s+(\S.*\S)\s*$/)
981 :     {
982 :     $genome = $1;
983 :     $role = $3;
984 :     $who = $2;
985 :     foreach $peg ($figN->seqs_with_role($role,$who,$genome))
986 :     {
987 :     $func = $figN->function_of($peg,$who);
988 :     print "$peg\t$func\n";
989 :     }
990 :     print "\n";
991 :     }
992 :     elsif ($req =~ /^\s*load_all\s*$/)
993 :     {
994 :     if ($figN->load_all)
995 :     {
996 :     print "imported everything\n";
997 :     }
998 :     }
999 :     elsif ($req =~ /^\s*dsims\s+(\S+)(\s+(\S+)\s+(\S+)\s+(\S+))?\s*$/)
1000 :     {
1001 :     $file = $1;
1002 :     $maxN = $3 ? $3 : 500;
1003 :     $maxP = $4 ? $4 : 1,0e-5;
1004 :     $select = $5 ? $5 : "raw";
1005 :     if (open(TMP,"<$file"))
1006 :     {
1007 :     $_ = <TMP>;
1008 :     while (defined($_) && ($_ =~ /^>(\S+)/))
1009 :     {
1010 :     $id = $1;
1011 :     @seqs = ();
1012 :     while (defined($_ = <TMP>) && ($_ !~ /^>/))
1013 :     {
1014 :     push(@seqs,$_);
1015 :     }
1016 :     $seq = join("",@seqs);
1017 :     $seq =~ s/\s//gs;
1018 :     if (@sims = $figN->dsims($id,$seq,$maxN,$maxP,$select,0))
1019 :     {
1020 :     print "$id\t",length($seq),"\n\n";
1021 :     foreach $sim (@sims)
1022 :     {
1023 :     $func = $figN->function_of($sim->id2);
1024 :     print join("\t",($sim->id2(),
1025 :     $sim->ln2,
1026 :     $sim->psc,
1027 :     $sim->b1,
1028 :     $sim->e1,
1029 :     $sim->b2,
1030 :     $sim->e2,
1031 :     $sim->iden,
1032 :     $func)),"\n";
1033 :     }
1034 :     print "\n";
1035 :     }
1036 :     }
1037 :     close(TMP);
1038 :     }
1039 :     print "\n";
1040 :     }
1041 :     elsif ($req =~ /^\s*access_sims\s+(\S+)?\s*$/)
1042 :     {
1043 :     $opt = $1 ? $1 : "";
1044 :     foreach $peg ("fig|562.1.peg.14","fig|630.1.peg.589","fig|731.2.peg.1626","fig|75985.1.peg.2319","fig|294.1.peg.4630","fig|305.1.peg.2718","fig|292.1.peg.3262","fig|519.1.peg.4061","fig|633.1.peg.2431","fig|384.1.peg.2479")
1045 :     {
1046 :     @sims = $figN->sims($peg,600,1.0e-3,"raw",0);
1047 :     if ($opt =~ /expand/)
1048 :     {
1049 :     foreach $sim (@sims)
1050 :     {
1051 :     @map = $figN->mapped_prot_ids($sim->id2);
1052 :     foreach $to (@map)
1053 :     {
1054 :     if ($opt =~ /func/)
1055 :     {
1056 :     @funcs = $figN->function_of($to->[0]);
1057 :     }
1058 :     }
1059 :     }
1060 :     }
1061 :     elsif ($opt =~ /func/)
1062 :     {
1063 :     foreach $sim (@sims)
1064 :     {
1065 :     @funcs = $figN->function_of($sim->id2);
1066 :     }
1067 :     }
1068 :     }
1069 :     }
1070 :     elsif ($req =~ /^\s*sims\s+(\S+)(\s+(\S+)\s+(\S+)\s+(\S+)\s+(\d))?\s*$/)
1071 :     {
1072 :     $id = $1;
1073 :     $maxN = $3 ? $3 : 500;
1074 :     $maxP = $4 ? $4 : 1,0e-5;
1075 :     $select = $5 ? $5 : "raw";
1076 :     $tran = $6;
1077 :    
1078 :     $func = $figN->function_of($id);
1079 :     if (@sims = $figN->sims($id,$maxN,$maxP,$select))
1080 :     {
1081 :     print &padded($id,20),"\t",$sims[0]->ln1."\t$func\n\n";
1082 :     foreach $sim (@sims)
1083 :     {
1084 :     $func = $figN->function_of($sim->id2);
1085 :     if ($tran) { $func = $figN->translate_function($func) }
1086 :    
1087 :     $org = $figN->org_of($sim->id2);
1088 :     print join("\t",(&padded($sim->id2,20),
1089 :     $sim->ln2,
1090 :     $sim->psc,
1091 :     $sim->b1,
1092 :     $sim->e1,
1093 :     $sim->b2,
1094 :     $sim->e2,
1095 :     $sim->iden,
1096 :     $org,
1097 :     $func)),"\n";
1098 :     }
1099 :     }
1100 :     print "\n";
1101 :     }
1102 :     elsif ($req =~ /^\s*ids_in_set\s+(\d+)\s+(\S+)\s+(\S+)\s*$/)
1103 :     {
1104 :     $set = $1;
1105 :     $relation = $2;
1106 :     $set_name = $3;
1107 :     print "$set_name $set\n\n";
1108 :     @ids = $figN->ids_in_set($set,$relation,$set_name);
1109 :     while (@ids > 0)
1110 :     {
1111 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
1112 :     print join("\t",@tmp),"\n";
1113 :     }
1114 :     print "\n";
1115 :     }
1116 :    
1117 :     elsif ($req =~ /^\s*get_translations\s+(\S+)(\s+tab)?\s*$/i)
1118 :     {
1119 :     $file = $1;
1120 :     $tab = $2 ? 1 : 0;
1121 :     if (open(TMP,"<$file"))
1122 :     {
1123 :     while (defined($_ = <TMP>))
1124 :     {
1125 :     foreach $id ($_ =~ /\S+/g)
1126 :     {
1127 :     if ($seq = $figN->get_translation($id))
1128 :     {
1129 :     if ($tab)
1130 :     {
1131 :     print "$id\t$seq\n";
1132 :     }
1133 :     else
1134 :     {
1135 :     $figN->display_id_and_seq($id,\$seq);
1136 :     }
1137 :     }
1138 :     }
1139 :     }
1140 :     close(TMP);
1141 :     }
1142 :     else
1143 :     {
1144 :     print STDERR "could not open $file\n";
1145 :     }
1146 :     print "\n";
1147 :     }
1148 :    
1149 :     elsif ($req =~ /^\s*add_annotation\s+(\S+)\s+(\S+)\s*$/)
1150 :     {
1151 :     $fid = $1;
1152 :     $user = $2;
1153 :     print "Type in annotation (end with \".\" at start of line)\n>> ";
1154 :     @ann = ();
1155 :     while (defined($_ = <STDIN>) && ($_ !~ /^\./))
1156 :     {
1157 :     push(@ann,$_);
1158 :     print ">> ";
1159 :     }
1160 :     print $figN->add_annotation($fid,$user,join("",@ann)),"\n\n";
1161 :     }
1162 :    
1163 : efrank 1.1 elsif ($req =~ /^\s*h\s+(\S+)/)
1164 :     {
1165 :     if (-s "Help/$1")
1166 :     {
1167 :     @tmp = `cat Help/$1`;
1168 :     print "\n",join("",@tmp),"\n";
1169 :     }
1170 :     else
1171 :     {
1172 :     print "sorry, no help for $1\n\n";
1173 :     }
1174 :     }
1175 :     else
1176 :     {
1177 :     print "invalid command\n";
1178 :     }
1179 :     print "\n";
1180 :     $req = "";
1181 :    
1182 :     if ($time_cmds)
1183 :     {
1184 :     $t2 = gettimeofday;
1185 :     print $t2-$t1," seconds to execute command\n\n";
1186 :     }
1187 :     }
1188 :     sub padded {
1189 :     my($x,$n) = @_;
1190 :    
1191 :     if (length($x) < $n)
1192 :     {
1193 :     return $x . (" " x ($n - length($x)));
1194 :     }
1195 :     return $x;
1196 :     }
1197 :    
1198 :     sub get_req {
1199 :     my($x);
1200 :    
1201 :     print "?? ";
1202 :     $x = <STDIN>;
1203 :     while (defined($x) && ($x =~ /^h$/i) )
1204 :     {
1205 :     &help;
1206 :     print "?? ";
1207 :     $x = <STDIN>;
1208 :     }
1209 :    
1210 :     if ((! defined($x)) || ($x =~ /^\s*[qQxX]/))
1211 :     {
1212 :     return "";
1213 :     }
1214 :     else
1215 :     {
1216 :     if ($echo)
1217 :     {
1218 :     print ">> $x\n";
1219 :     }
1220 :     return $x;
1221 :     }
1222 :     }
1223 :    
1224 :     sub help {
1225 :     print <<END;
1226 : mkubal 1.2 DB Current DB
1227 :     abbrev genome_name
1228 :     add_annotation FID User [ prompted for annotation; terminate with "." at start of line ]
1229 :     add_chromosomal_clusters File
1230 :     *add_genome GenomeDir
1231 :     add_pch_pins File
1232 :     all_compounds
1233 :     all_features GenomeID Type
1234 :     all_maps
1235 : efrank 1.1 all_protein_families
1236 : mkubal 1.2 all_reactions
1237 :     all_roles
1238 :     all_sets Relation SetName
1239 :     assign_function PEG User [conf=X] Function
1240 :     assign_functionF User File
1241 :     assignments_made who date G1 G2 ... [ none => all ]
1242 :     auto_assign PEG [Seq]
1243 :     auto_assignF User FileOfPEGs
1244 :     auto_assignG User GenomeID1 GenomeID2 ...
1245 :     between n1 n2 n3
1246 :     blast PEG [against nr]
1247 :     blastit PEG seq db maxP
1248 :     boundaries_of Loc
1249 :     build_tree_of_complete min_for_label
1250 :     by_alias alias
1251 :     by_fig_id FID1 FID2
1252 :     cas CID
1253 :     cas_to_cid cas
1254 :     catalyzed_by RID
1255 : efrank 1.1 catalyzes role
1256 : mkubal 1.2 cgi_url
1257 :     clean_tmp
1258 :     close_genes FID distance
1259 :     comp2react CID
1260 :     contig_ln GenomeID Contig
1261 :     coupling_and_evidence FID Bound SimCutoff CouplingCutoff
1262 :     crude_estimate_of_distance GenomeID1 GenomeID2
1263 :     delete_genomes G1 G2 G3 ...Gn
1264 :     displayable_reaction RID
1265 :     dna_seq GenomeID Loc
1266 :     dsims FastaFile [MaxN MaxPsc Select] *** select defaults to raw
1267 :     ec_to_maps EC
1268 :     ec_name EC
1269 :     expand_ec EC
1270 :     epoch_to_readable [gives readable version of current time]
1271 :     export_chromosomal_clusters
1272 :     export_pch_pins
1273 :     export_set Relation SetName File
1274 :     exportable_subsystem Subsystem
1275 :     extract_seq ContigsFile loc
1276 :     all_exchangable_subsystems
1277 :     family_function Family
1278 :     fast_coupling FID Bound CouplingCutoff
1279 :     feature_aliases FID
1280 :     feature_annotations FID
1281 :     feature_location FID
1282 :     file2N File
1283 :     ftype FID
1284 :     function_of ID [all] [trans]
1285 :     genes_in_region GenomeID Contig Beg End
1286 :     genome_of PEG
1287 :     genomes [complete|Pat]
1288 :     genome_counts [complete]
1289 :     genome_version GenomeID
1290 :     genus_species GenomeID
1291 :     get_translation ID
1292 :     get_translations File [tab]
1293 : efrank 1.1 h [command] *** h h for help on how to use help ***
1294 : mkubal 1.2 hypo Function
1295 :     ids_in_family Family
1296 :     ids_in_set WhichSet Relation SetName
1297 :     in_cluster_with PEG
1298 :     in_family FID
1299 :     in_pch_pin_with FID
1300 :     in_sets Which Relation SetName
1301 :     is_archaeal GenomeID
1302 :     is_bacterial GenomeID
1303 :     is_eukaryotic GenomeID
1304 :     is_prokaryotic GenomeID
1305 :     is_exchangable_subsystem Subsystem
1306 :     is_real_feature FID
1307 :     largest_clusters FileOfRoles user
1308 :     load_all
1309 : efrank 1.1 map_to_ecs map
1310 : mkubal 1.2 map_name map
1311 :     mapped_prot_ids ID
1312 :     maps_to_id ID
1313 :     max n1 n2 n3 ...
1314 :     merged_related_annotations PEG1 PEG2 ... PEGn
1315 :     min n1 n2 n3 ...
1316 :     names_of_compound
1317 :     neighborhood_of_role role
1318 :     org_of prot_id
1319 :     pegs_of GenomeID
1320 :     possibly_truncated FID
1321 :     reaction2comp RID
1322 :     related_by_func_sim PEG user
1323 :     reversible RID
1324 :     rnas_of GenomeID
1325 :     roles_of_function function
1326 :     search_index pattern
1327 :     seqs_with_role role who
1328 :     seqs_with_roles_in_genomes genomes roles made_by
1329 :     sims PEG maxN maxP select
1330 :     sort_fids_by_taxonomy FID1 FID2 FID3 ...
1331 :     sort_genomes_by_taxonomy GenomeID1 GenomeID2 GenomeID3 ...
1332 :     sz_family family
1333 :     taxonomic_groups_of_complete min_for_labels
1334 :     taxonomy_of GenomeID
1335 :     translatable prot_id
1336 :     translate_function PEG user
1337 :     translated_function_of PEG user
1338 :     translation_length ID
1339 :     unique_functions PEGs user [make the pegs comma separated]
1340 :     verify_dir dir
1341 : efrank 1.1
1342 :     END
1343 :     }

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3