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

Annotation of /FigKernelScripts/fig_net.pl

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : efrank 1.1 # -*- perl -*-
2 : olson 1.3 #
3 : golsen 1.4 # Copyright (c) 2003-2008 University of Chicago and Fellowship
4 : olson 1.3 # 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 : golsen 1.4
555 :     $funcO = $figN->function_of($peg);
556 :     if ($funcO ne $func)
557 : mkubal 1.2 {
558 : golsen 1.4 # assign_function writes annotation
559 :     $figN->assign_function($peg,$user,$func,$conf);
560 : mkubal 1.2 }
561 :     }
562 :     close(TMP);
563 :     }
564 :     }
565 :    
566 :     elsif ($req =~ /^\s*largest_clusters\s+(\S+)\s+(\S+)\s*$/)
567 :     {
568 :     $file = $1;
569 :     $user = $2;
570 :     my @tmp = `cat $file`;
571 :     chop @tmp;;
572 :     my @tmp1 = $figN->largest_clusters(\@tmp,$user);
573 :     print &Dumper(\@tmp1);
574 :     }
575 :     elsif ($req =~ /^\s*unique_functions\s+(\S+)\s+(\S+)\s*$/)
576 :     {
577 :     $pegs = $1;
578 :     $user = $2;
579 :     my @tmp = $figN->unique_functions([split(/,/,$pegs)],$user);
580 :     print &Dumper(\@tmp);
581 :     }
582 :     elsif ($req =~ /^\s*extract_seq\s+(\S+)\s+(\S+)\s*$/)
583 :     {
584 :     $contigsF = $1;
585 :     $loc = $2;
586 :     $contigs = &load_contigs($contigsF);
587 :     print &Dumper(&FIG::extract_seq($contigs,$loc));
588 :     }
589 :     elsif ($req =~ /^\s*is_bacterial\s+(\S+)\s*$/)
590 :     {
591 :     $genome = $1;
592 :     print $figN->is_bacterial($genome),"\n";;
593 :     }
594 :     elsif ($req =~ /^\s*is_archaeal\s+(\S+)\s*$/)
595 :     {
596 :     $genome = $1;
597 :     print $figN->is_archaeal($genome),"\n";
598 :     }
599 :     elsif ($req =~ /^\s*is_prokaryotic\s+(\S+)\s*$/)
600 :     {
601 :     $genome = $1;
602 :     print $figN->is_prokaryotic($genome),"\n";
603 :     }
604 :     elsif ($req =~ /^\s*is_eukaryotic\s+(\S+)\s*$/)
605 :     {
606 :     $genome = $1;
607 :     print $figN->is_eukaryotic($genome),"\n";
608 :     }
609 :     elsif ($req =~ /^\s*sort_genomes_by_taxonomy\s+(\S+(\s+\S+)*)\s*$/)
610 :     {
611 :     @list_of_genomes = split(/\s+/,$1);
612 :     print join(",",$figN->sort_genomes_by_taxonomy(@list_of_genomes)),"\n";
613 :     }
614 :     elsif ($req =~ /^\s*sort_fids_by_taxonomy\s+(\S+(\s+\S+)*)\s*$/)
615 :     {
616 :     @fids = split(/\s+/,$1);
617 :     print join(",",$figN->sort_fids_by_taxonomy(@fids)),"\n";
618 :     }
619 :     elsif ($req =~ /^\s*build_tree_of_complete\s+(\S+)\s*$/)
620 :     {
621 :     $min_for_label = $1;
622 :     print &Dumper($figN->build_tree_of_complete($min_for_label));
623 :     }
624 :     elsif ($req =~ /^\s*taxonomic_groups_of_complete\s+(\S+)\s*$/)
625 :     {
626 :     $min_for_labels = $1;
627 :     print &Dumper($figN->taxonomic_groups_of_complete($min_for_labels));
628 :     }
629 :     elsif ($req =~ /^\s*max\s+(((\d+)\s+)*\d+)\s*$/)
630 :     {
631 :     print $figN->max(split(/\s+/,$1)),"\n\n";
632 :     }
633 :     elsif ($req =~ /^\s*add_genome\s+((.*\/)?(\d+\.\d+))\s*$/)
634 :     {
635 :     $genomeF = $1;
636 :     $genome = $3;
637 :     if ((! -d "$FIG_Config::organisms/$genome") && ($figN->add_genome($genomeF)))
638 :     {
639 :     print "Added $genome\n";
640 :     }
641 :     else
642 :     {
643 :     print "Failed to add $genome from $genomeF\n";
644 :     }
645 :     }
646 :     elsif ($req =~ /^\s*delete_genomes\s+(\d.*\d)\s*$/)
647 :     {
648 :     $genomes = $1;
649 :     @genomes = split(/\s+/,$genomes);
650 :     if (@genomes > 0)
651 :     {
652 :     @bad_genomes = grep { ! -d "$FIG_Config::organisms/$_" } @genomes;
653 :     if (@bad_genomes > 0)
654 :     {
655 :     print "Bad Genomes: ",join(" ",@bad_genomes),"\n";
656 :     }
657 :     else
658 :     {
659 :     $figN->delete_genomes(\@genomes);
660 :     print "Completed deleting ",join(" ",@genomes),"\n";
661 :     }
662 :     }
663 :     }
664 :     elsif ($req =~ /^\s*min\s+(((\d+)\s+)*\d+)\s*$/)
665 :     {
666 :     print $figN->min(split(/\s+/,$1)),"\n\n";
667 :     }
668 :     elsif ($req =~ /^\s*between\s+(\d+)\s+(\d+)\s+(\d+)\s*$/)
669 :     {
670 :     print $figN->between($1,$2,$3),"\n\n";
671 :     }
672 :     elsif ($req =~ /^\s*merge_related_annotations\s+(\S.*\S)\s*$/)
673 :     {
674 :     $pegs = [split(/\s+/,$1)];
675 :     my @tmp = $figN->merged_related_annotations($pegs);
676 :     print &Dumper(\@tmp);
677 :     print "\n";
678 :     }
679 :     elsif ($req =~ /^\s*genus_species\s+(\d+\.\d+)\s*$/)
680 :     {
681 :     print $figN->genus_species($1),"\n\n";
682 :     }
683 :     elsif ($req =~ /^\s*genome_counts(\s+(complete))?/)
684 :     {
685 :     $counts = $figN->genome_counts($2);
686 :     print "$counts\n";
687 :     }
688 :     elsif ($req =~ /^\s*file2N\s+(\S+)\s*$/)
689 :     {
690 :     print $figN->file2N($1),"\n\n";
691 :     }
692 :     elsif ($req =~ /^\s*genome_version\s+(\S+)\s*$/)
693 :     {
694 :     $_ = defined($_ = $figN->genome_version($1)) ? $_ : "undefined";
695 :     print "$_\n\n";
696 :     }
697 :    
698 :     elsif ($req =~ /^\s*taxonomy_of\s+(\d+\.\d+)\s*$/)
699 :     {
700 :     print $figN->taxonomy_of($1),"\n\n";
701 :     }
702 :    
703 :     elsif ($req =~ /^\s*fast_coupling\s+(fig\|\d+\.\d+\.peg\.\d+)\s+(\d+)\s+(\S+)/)
704 :     {
705 :     $fid = $1;
706 :     $bound = $2;
707 :     $coup_cutoff = $3;
708 :     @tmp = $figN->fast_coupling($fid,$bound,$coup_cutoff);
709 :     print &Dumper(\@tmp),"\n\n";
710 :     }
711 :    
712 :     elsif ($req =~ /^\s*auto_assign\s+(fig\|\d+\.\d+\.peg\.\d+)(\s+(\S+))?\s*$/)
713 :     {
714 :     $fid = $1;
715 :     $seq = $3;
716 :     print $figN->auto_assign($fid,$seq),"\n\n";
717 :     }
718 :    
719 :     elsif ($req =~ /^\s*auto_assignG\s+(\S+)\s+(\S.*\S)\s*$/)
720 :     {
721 :     $user = $1;
722 :     @genomes = split(/\s+/,$2);
723 :     foreach $genome (@genomes)
724 :     {
725 :     if (-s "$FIG_Config::organisms/$genome/Features/peg/tbl")
726 :     {
727 :     print STDERR "making assignments for $genome\n";
728 :     system "cut -f1 $FIG_Config::organisms/$genome/Features/peg/tbl > tmp$$ ; fig auto_assignF $user tmp$$";
729 :     unlink("tmp$$");
730 :     }
731 :     }
732 :     print "\n";
733 :     }
734 :    
735 :     elsif (($req =~ /^\s*auto_assignF\s+(\S+)\s+(\S+)\s*$/) &&
736 :     ($file = $2) && (-s $file) &&
737 :     ($user = $1))
738 :     {
739 :     $n = 0;
740 :     foreach $assignment (`cut -f1 $file | auto_assign | make_calls`)
741 :     {
742 :     if ($assignment =~ /^(\S+)\t(\S[^\t]+\S)(\t(\S))?\s*$/)
743 :     {
744 :     $prot = $1;
745 :     $function = $2;
746 :     $conf = $4 ? $4 : "";
747 :     $n++;
748 : golsen 1.4
749 :     # assign_function does everything now
750 :     $figN->assign_function($prot,$user,$function,$conf);
751 : mkubal 1.2 }
752 :     }
753 :     close(TMP);
754 :     print STDERR "$n assignments made (all attributed to $user)\n";
755 :     }
756 :    
757 :     elsif ($req =~ /^\s*assignments_made\s+(\S+)\s+(\d{1,2}\/\d{1,2}\/\d{4})(\s+(\S.*\S))?\s*$/)
758 :     {
759 :     $who = $1;
760 :     $date = $2;
761 :     if ($3)
762 :     {
763 :     $genomes = [split(/\s+/,$4)];
764 :     }
765 :     else
766 :     {
767 :     $genomes = [$figN->genomes];
768 :     }
769 :    
770 :     foreach $assignment ($figN->assignments_made($genomes,$who,$date))
771 :     {
772 :     print join("\t",@$assignment),"\n";
773 :     }
774 :     }
775 :    
776 :     elsif ($req =~ /^\s*genes_in_region\s+(\d+\.\d+)\s+(\S+)\s+(\d+)\s+(\d+)\s*$/)
777 :     {
778 :     print &Dumper($figN->genes_in_region($1,$2,$3,$4)),"\n\n";
779 :     }
780 :     elsif ($req =~ /^\s*all_features\s+(\d+\.\d+)\s+(\S+)\s*$/)
781 :     {
782 :     @ids = sort { $figN->by_fig_id($a,$b) } $figN->all_features($1,$2);
783 :     while (@ids > 0)
784 :     {
785 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
786 :     print join("\t",@tmp),"\n";
787 :     }
788 :     print "\n";
789 :     }
790 :     elsif ($req =~ /^\s*function_of\s+(\S+)\s*(\S+)?\s*$/)
791 :     {
792 :     if ($2)
793 :     {
794 :     $extra = $2;
795 :     $all = ($extra =~ /all/i);
796 :     $tran = ($extra =~ /tran/i);
797 :     }
798 :     if ($all)
799 :     {
800 :     foreach $x ($figN->function_of($1))
801 :     {
802 :     ($who,$func) = @$x;
803 :     if ($tran) { $func = $figN->translate_function($func) }
804 :     print &padded($who,30)," $func\n";
805 :     }
806 :     }
807 :     else
808 :     {
809 :     $func = $figN->function_of($1);
810 :     if ($tran) { $func = $figN->translate_function($func) }
811 :     print "$func\n";
812 :     }
813 :     print "\n";
814 :     }
815 :     elsif ($req =~ /^\s*in_cluster_with\s+(\S+)\s*$/)
816 :     {
817 :     $peg = $1;
818 :     @pegs = $figN->in_cluster_with($peg);
819 :     $func = $figN->function_of($peg);
820 :     print "$peg\t$func\n\n";
821 :     foreach $peg (@pegs)
822 :     {
823 :     $func = $figN->function_of($peg);
824 :     print "$peg\t$func\n";
825 :     }
826 :     print "\n";
827 :     }
828 :     elsif ($req =~ /^\s*feature_location\s+(\S+)\s*$/)
829 :     {
830 :     $fid = $1;
831 :     if ($loc = $figN->feature_location($fid))
832 :     {
833 :     print "$loc\n";
834 :     }
835 :     else
836 :     {
837 :     print "no location\n";
838 :     }
839 :     }
840 :     elsif ($req =~ /^\s*translation_length\s+(\S+)\s*$/)
841 :     {
842 :     $fid = $1;
843 :     if ($len = $figN->translation_length($fid))
844 :     {
845 :     print "$len\n";
846 :     }
847 :     else
848 :     {
849 :     print "no length for $fid\n";
850 :     }
851 :     }
852 :     elsif ($req =~ /^\s*mapped_prot_ids\s+(\S+)\s*$/)
853 :     {
854 :     foreach $x ($figN->mapped_prot_ids($1))
855 :     {
856 :     ($id,$len) = @$x;
857 :     print &padded($id,20),"\t$len\n";
858 :     }
859 :     print "\n";
860 :     }
861 :     elsif ($req =~ /^\s*boundaries_of\s+(\S+)\s*$/)
862 :     {
863 :     print join("_",$figN->boundaries_of($1)),"\n\n";
864 :     }
865 :     elsif ($req =~ /^\s*family_function\s+(\d+)\s*$/)
866 :     {
867 :     $family = $1;
868 :     $func = $figN->family_function($family);
869 :     print "family $family: $func\n\n";
870 :     }
871 :     elsif ($req =~ /^\s*in_family\s+(\S+)\s*$/)
872 :     {
873 :     $id = $1;
874 :     $n = $figN->in_family($id);
875 :     print "$id is in family $n\n\n";
876 :     }
877 :     elsif ($req =~ /^\s*ids_in_family\s+(\d+)\s*$/)
878 :     {
879 :     $family = $1;
880 :     $func = $figN->family_function($family);
881 :     print "family $family: $func\n\n";
882 :     @ids = $figN->ids_in_family($family);
883 :     while (@ids > 0)
884 :     {
885 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
886 :     print join("\t",@tmp),"\n";
887 :     }
888 :     print "\n";
889 :    
890 :     }
891 :     elsif ($req =~ /^\s*in_sets\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
892 :     {
893 :     $id = $1;
894 :     $relation = $2;
895 :     $set_name = $3;
896 :     print "$id is in set(s) ",join(",",$figN->in_sets($id,$relation,$set_name)),"\n\n";
897 :     }
898 :     elsif ($req =~ /^\s*in_pch_pin_with\s+(\S+)\s*$/)
899 :     {
900 :     $id = $1;
901 :     print "$id is in set(s) ",join(",",$figN->in_pch_pin_with($id)),"\n\n";
902 :     }
903 :     elsif ($req =~ /^\s*exportable_subsystem\s+(\S.*\S+)\s*$/)
904 :     {
905 :     my $ssa = $1;
906 :     my($spreadsheet,$notes) = $figN->exportable_subsystem($ssa);
907 :     print join("",@$spreadsheet),join("",@$notes),"\n";
908 :     }
909 :     elsif ($req =~ /^\s*is_exchangable_subsystem\s+(\S.*\S+)\s*$/)
910 :     {
911 :     my $ssa = $1;
912 :     print $figN->is_exchangable_subsystem($ssa),"\n";
913 :     }
914 :     elsif ($req =~ /^\s*all_exchangable_subsystems\s*$/)
915 :     {
916 :     print join("\n",$figN->all_exchangable_subsystems),"\n";
917 :     }
918 :     elsif ($req =~ /^\s*export_set\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
919 :     {
920 :     $relation = $1;
921 :     $set_name = $2;
922 :     $file = $3;
923 :     print $figN->export_set($relation,$set_name,$file),"\n\n";
924 :     }
925 :     elsif ($req =~ /^\s*export_chromosomal_clusters\s*$/)
926 :     {
927 :     print $figN->export_set("chromosomal_clusters","cluster_id","$FIG_Config::global/chromosomal_clusters"),"\n\n";
928 :     }
929 :     elsif ($req =~ /^\s*export_pch_pins\s*$/)
930 :     {
931 :     print $figN->export_set("pch_pins","pin","$FIG_Config::global/pch_pins"),"\n\n";
932 :     }
933 :     elsif ($req =~ /^\s*add_chromosomal_clusters\s+(\S+)\s*$/)
934 :     {
935 :     $file = $1;
936 :     print $figN->add_chromosomal_clusters($file),"\n\n";
937 :     }
938 :     elsif ($req =~ /^\s*add_pch_pins\s+(\S+)\s*$/)
939 :     {
940 :     $file = $1;
941 :     print $figN->add_pch_pins($file),"\n\n";
942 :     }
943 :     elsif ($req =~ /^\s*all_sets\s+(\S+)\s+(\S+)\s*$/)
944 :     {
945 :     $relation = $1;
946 :     $set_name = $2;
947 :     print "Set\tSize\n\n";
948 :     foreach $set ($figN->all_sets($relation,$set_name))
949 :     {
950 :     print "$set\t",$figN->sz_set($set,$relation,$set_name),"\n";
951 :     }
952 :     print "\n";
953 :     }
954 :     elsif ($req =~ /^\s*seqs_with_role\s+(\S+)\s+(\S+)\s+(\S.*\S)\s*$/)
955 :     {
956 :     $genome = $1;
957 :     $role = $3;
958 :     $who = $2;
959 :     foreach $peg ($figN->seqs_with_role($role,$who,$genome))
960 :     {
961 :     $func = $figN->function_of($peg,$who);
962 :     print "$peg\t$func\n";
963 :     }
964 :     print "\n";
965 :     }
966 :     elsif ($req =~ /^\s*load_all\s*$/)
967 :     {
968 :     if ($figN->load_all)
969 :     {
970 :     print "imported everything\n";
971 :     }
972 :     }
973 :     elsif ($req =~ /^\s*dsims\s+(\S+)(\s+(\S+)\s+(\S+)\s+(\S+))?\s*$/)
974 :     {
975 :     $file = $1;
976 :     $maxN = $3 ? $3 : 500;
977 :     $maxP = $4 ? $4 : 1,0e-5;
978 :     $select = $5 ? $5 : "raw";
979 :     if (open(TMP,"<$file"))
980 :     {
981 :     $_ = <TMP>;
982 :     while (defined($_) && ($_ =~ /^>(\S+)/))
983 :     {
984 :     $id = $1;
985 :     @seqs = ();
986 :     while (defined($_ = <TMP>) && ($_ !~ /^>/))
987 :     {
988 :     push(@seqs,$_);
989 :     }
990 :     $seq = join("",@seqs);
991 :     $seq =~ s/\s//gs;
992 :     if (@sims = $figN->dsims($id,$seq,$maxN,$maxP,$select,0))
993 :     {
994 :     print "$id\t",length($seq),"\n\n";
995 :     foreach $sim (@sims)
996 :     {
997 :     $func = $figN->function_of($sim->id2);
998 :     print join("\t",($sim->id2(),
999 :     $sim->ln2,
1000 :     $sim->psc,
1001 :     $sim->b1,
1002 :     $sim->e1,
1003 :     $sim->b2,
1004 :     $sim->e2,
1005 :     $sim->iden,
1006 :     $func)),"\n";
1007 :     }
1008 :     print "\n";
1009 :     }
1010 :     }
1011 :     close(TMP);
1012 :     }
1013 :     print "\n";
1014 :     }
1015 :     elsif ($req =~ /^\s*access_sims\s+(\S+)?\s*$/)
1016 :     {
1017 :     $opt = $1 ? $1 : "";
1018 :     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")
1019 :     {
1020 :     @sims = $figN->sims($peg,600,1.0e-3,"raw",0);
1021 :     if ($opt =~ /expand/)
1022 :     {
1023 :     foreach $sim (@sims)
1024 :     {
1025 :     @map = $figN->mapped_prot_ids($sim->id2);
1026 :     foreach $to (@map)
1027 :     {
1028 :     if ($opt =~ /func/)
1029 :     {
1030 :     @funcs = $figN->function_of($to->[0]);
1031 :     }
1032 :     }
1033 :     }
1034 :     }
1035 :     elsif ($opt =~ /func/)
1036 :     {
1037 :     foreach $sim (@sims)
1038 :     {
1039 :     @funcs = $figN->function_of($sim->id2);
1040 :     }
1041 :     }
1042 :     }
1043 :     }
1044 :     elsif ($req =~ /^\s*sims\s+(\S+)(\s+(\S+)\s+(\S+)\s+(\S+)\s+(\d))?\s*$/)
1045 :     {
1046 :     $id = $1;
1047 :     $maxN = $3 ? $3 : 500;
1048 :     $maxP = $4 ? $4 : 1,0e-5;
1049 :     $select = $5 ? $5 : "raw";
1050 :     $tran = $6;
1051 :    
1052 :     $func = $figN->function_of($id);
1053 :     if (@sims = $figN->sims($id,$maxN,$maxP,$select))
1054 :     {
1055 :     print &padded($id,20),"\t",$sims[0]->ln1."\t$func\n\n";
1056 :     foreach $sim (@sims)
1057 :     {
1058 :     $func = $figN->function_of($sim->id2);
1059 :     if ($tran) { $func = $figN->translate_function($func) }
1060 :    
1061 :     $org = $figN->org_of($sim->id2);
1062 :     print join("\t",(&padded($sim->id2,20),
1063 :     $sim->ln2,
1064 :     $sim->psc,
1065 :     $sim->b1,
1066 :     $sim->e1,
1067 :     $sim->b2,
1068 :     $sim->e2,
1069 :     $sim->iden,
1070 :     $org,
1071 :     $func)),"\n";
1072 :     }
1073 :     }
1074 :     print "\n";
1075 :     }
1076 :     elsif ($req =~ /^\s*ids_in_set\s+(\d+)\s+(\S+)\s+(\S+)\s*$/)
1077 :     {
1078 :     $set = $1;
1079 :     $relation = $2;
1080 :     $set_name = $3;
1081 :     print "$set_name $set\n\n";
1082 :     @ids = $figN->ids_in_set($set,$relation,$set_name);
1083 :     while (@ids > 0)
1084 :     {
1085 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
1086 :     print join("\t",@tmp),"\n";
1087 :     }
1088 :     print "\n";
1089 :     }
1090 :    
1091 :     elsif ($req =~ /^\s*get_translations\s+(\S+)(\s+tab)?\s*$/i)
1092 :     {
1093 :     $file = $1;
1094 :     $tab = $2 ? 1 : 0;
1095 :     if (open(TMP,"<$file"))
1096 :     {
1097 :     while (defined($_ = <TMP>))
1098 :     {
1099 :     foreach $id ($_ =~ /\S+/g)
1100 :     {
1101 :     if ($seq = $figN->get_translation($id))
1102 :     {
1103 :     if ($tab)
1104 :     {
1105 :     print "$id\t$seq\n";
1106 :     }
1107 :     else
1108 :     {
1109 :     $figN->display_id_and_seq($id,\$seq);
1110 :     }
1111 :     }
1112 :     }
1113 :     }
1114 :     close(TMP);
1115 :     }
1116 :     else
1117 :     {
1118 :     print STDERR "could not open $file\n";
1119 :     }
1120 :     print "\n";
1121 :     }
1122 :    
1123 :     elsif ($req =~ /^\s*add_annotation\s+(\S+)\s+(\S+)\s*$/)
1124 :     {
1125 :     $fid = $1;
1126 :     $user = $2;
1127 :     print "Type in annotation (end with \".\" at start of line)\n>> ";
1128 :     @ann = ();
1129 :     while (defined($_ = <STDIN>) && ($_ !~ /^\./))
1130 :     {
1131 :     push(@ann,$_);
1132 :     print ">> ";
1133 :     }
1134 :     print $figN->add_annotation($fid,$user,join("",@ann)),"\n\n";
1135 :     }
1136 :    
1137 : efrank 1.1 elsif ($req =~ /^\s*h\s+(\S+)/)
1138 :     {
1139 :     if (-s "Help/$1")
1140 :     {
1141 :     @tmp = `cat Help/$1`;
1142 :     print "\n",join("",@tmp),"\n";
1143 :     }
1144 :     else
1145 :     {
1146 :     print "sorry, no help for $1\n\n";
1147 :     }
1148 :     }
1149 :     else
1150 :     {
1151 :     print "invalid command\n";
1152 :     }
1153 :     print "\n";
1154 :     $req = "";
1155 :    
1156 :     if ($time_cmds)
1157 :     {
1158 :     $t2 = gettimeofday;
1159 :     print $t2-$t1," seconds to execute command\n\n";
1160 :     }
1161 :     }
1162 :     sub padded {
1163 :     my($x,$n) = @_;
1164 :    
1165 :     if (length($x) < $n)
1166 :     {
1167 :     return $x . (" " x ($n - length($x)));
1168 :     }
1169 :     return $x;
1170 :     }
1171 :    
1172 :     sub get_req {
1173 :     my($x);
1174 :    
1175 :     print "?? ";
1176 :     $x = <STDIN>;
1177 :     while (defined($x) && ($x =~ /^h$/i) )
1178 :     {
1179 :     &help;
1180 :     print "?? ";
1181 :     $x = <STDIN>;
1182 :     }
1183 :    
1184 :     if ((! defined($x)) || ($x =~ /^\s*[qQxX]/))
1185 :     {
1186 :     return "";
1187 :     }
1188 :     else
1189 :     {
1190 :     if ($echo)
1191 :     {
1192 :     print ">> $x\n";
1193 :     }
1194 :     return $x;
1195 :     }
1196 :     }
1197 :    
1198 :     sub help {
1199 :     print <<END;
1200 : mkubal 1.2 DB Current DB
1201 :     abbrev genome_name
1202 :     add_annotation FID User [ prompted for annotation; terminate with "." at start of line ]
1203 :     add_chromosomal_clusters File
1204 :     *add_genome GenomeDir
1205 :     add_pch_pins File
1206 :     all_compounds
1207 :     all_features GenomeID Type
1208 :     all_maps
1209 : efrank 1.1 all_protein_families
1210 : mkubal 1.2 all_reactions
1211 :     all_roles
1212 :     all_sets Relation SetName
1213 :     assign_function PEG User [conf=X] Function
1214 :     assign_functionF User File
1215 :     assignments_made who date G1 G2 ... [ none => all ]
1216 :     auto_assign PEG [Seq]
1217 :     auto_assignF User FileOfPEGs
1218 :     auto_assignG User GenomeID1 GenomeID2 ...
1219 :     between n1 n2 n3
1220 :     blast PEG [against nr]
1221 :     blastit PEG seq db maxP
1222 :     boundaries_of Loc
1223 :     build_tree_of_complete min_for_label
1224 :     by_alias alias
1225 :     by_fig_id FID1 FID2
1226 :     cas CID
1227 :     cas_to_cid cas
1228 :     catalyzed_by RID
1229 : efrank 1.1 catalyzes role
1230 : mkubal 1.2 cgi_url
1231 :     clean_tmp
1232 :     close_genes FID distance
1233 :     comp2react CID
1234 :     contig_ln GenomeID Contig
1235 :     coupling_and_evidence FID Bound SimCutoff CouplingCutoff
1236 :     crude_estimate_of_distance GenomeID1 GenomeID2
1237 :     delete_genomes G1 G2 G3 ...Gn
1238 :     displayable_reaction RID
1239 :     dna_seq GenomeID Loc
1240 :     dsims FastaFile [MaxN MaxPsc Select] *** select defaults to raw
1241 :     ec_to_maps EC
1242 :     ec_name EC
1243 :     expand_ec EC
1244 :     epoch_to_readable [gives readable version of current time]
1245 :     export_chromosomal_clusters
1246 :     export_pch_pins
1247 :     export_set Relation SetName File
1248 :     exportable_subsystem Subsystem
1249 :     extract_seq ContigsFile loc
1250 :     all_exchangable_subsystems
1251 :     family_function Family
1252 :     fast_coupling FID Bound CouplingCutoff
1253 :     feature_aliases FID
1254 :     feature_annotations FID
1255 :     feature_location FID
1256 :     file2N File
1257 :     ftype FID
1258 :     function_of ID [all] [trans]
1259 :     genes_in_region GenomeID Contig Beg End
1260 :     genome_of PEG
1261 :     genomes [complete|Pat]
1262 :     genome_counts [complete]
1263 :     genome_version GenomeID
1264 :     genus_species GenomeID
1265 :     get_translation ID
1266 :     get_translations File [tab]
1267 : efrank 1.1 h [command] *** h h for help on how to use help ***
1268 : mkubal 1.2 hypo Function
1269 :     ids_in_family Family
1270 :     ids_in_set WhichSet Relation SetName
1271 :     in_cluster_with PEG
1272 :     in_family FID
1273 :     in_pch_pin_with FID
1274 :     in_sets Which Relation SetName
1275 :     is_archaeal GenomeID
1276 :     is_bacterial GenomeID
1277 :     is_eukaryotic GenomeID
1278 :     is_prokaryotic GenomeID
1279 :     is_exchangable_subsystem Subsystem
1280 :     is_real_feature FID
1281 :     largest_clusters FileOfRoles user
1282 :     load_all
1283 : efrank 1.1 map_to_ecs map
1284 : mkubal 1.2 map_name map
1285 :     mapped_prot_ids ID
1286 :     maps_to_id ID
1287 :     max n1 n2 n3 ...
1288 :     merged_related_annotations PEG1 PEG2 ... PEGn
1289 :     min n1 n2 n3 ...
1290 :     names_of_compound
1291 :     neighborhood_of_role role
1292 :     org_of prot_id
1293 :     pegs_of GenomeID
1294 :     possibly_truncated FID
1295 :     reaction2comp RID
1296 :     related_by_func_sim PEG user
1297 :     reversible RID
1298 :     rnas_of GenomeID
1299 :     roles_of_function function
1300 :     search_index pattern
1301 :     seqs_with_role role who
1302 :     seqs_with_roles_in_genomes genomes roles made_by
1303 :     sims PEG maxN maxP select
1304 :     sort_fids_by_taxonomy FID1 FID2 FID3 ...
1305 :     sort_genomes_by_taxonomy GenomeID1 GenomeID2 GenomeID3 ...
1306 :     sz_family family
1307 :     taxonomic_groups_of_complete min_for_labels
1308 :     taxonomy_of GenomeID
1309 :     translatable prot_id
1310 :     translate_function PEG user
1311 :     translated_function_of PEG user
1312 :     translation_length ID
1313 :     unique_functions PEGs user [make the pegs comma separated]
1314 :     verify_dir dir
1315 : efrank 1.1
1316 :     END
1317 :     }

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3