[Bio] / FigKernelPackages / FIGO.pm Repository:
ViewVC logotype

Annotation of /FigKernelPackages/FIGO.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : overbeek 1.1 #
2 :     # Copyright (c) 2003-2006 University of Chicago and Fellowship
3 :     # for Interpretations of Genomes. All Rights Reserved.
4 :     #
5 :     # This file is part of the SEED Toolkit.
6 :     #
7 :     # The SEED Toolkit is free software. You can redistribute
8 :     # it and/or modify it under the terms of the SEED Toolkit
9 :     # Public License.
10 :     #
11 :     # You should have received a copy of the SEED Toolkit Public License
12 :     # along with this program; if not write to the University of Chicago
13 :     # at info@ci.uchicago.edu or the Fellowship for Interpretation of
14 :     # Genomes at veronika@thefig.info or download a copy from
15 :     # http://www.theseed.org/LICENSE.TXT.
16 :     #
17 :    
18 :     package FIGO;
19 :    
20 :     use strict;
21 :     use FIG;
22 :     use FIG_Config;
23 :     use SFXlate;
24 :     use SproutFIG;
25 :     use Tracer;
26 :     use Data::Dumper;
27 :     use FigFams;
28 : overbeek 1.3 use gjoparseblast;
29 : overbeek 1.1
30 :     sub new {
31 :     my($class,$low_level) = @_;
32 :    
33 :     my $fig;
34 :     if ($low_level && ($low_level =~ /sprout/i))
35 :     {
36 :     $fig = new SproutFIG($FIG_Config::sproutDB, $FIG_Config::sproutData);
37 :     }
38 :     else
39 :     {
40 :     $fig = new FIG;
41 :     }
42 :    
43 :     my $self = {};
44 :     $self->{_fig} = $fig;
45 : overbeek 1.3 $self->{_tmp_dir} = $FIG_Config::temp;
46 : overbeek 1.1 return bless $self, $class;
47 :     }
48 :    
49 :     sub genomes {
50 :     my($self,@constraints) = @_;
51 :     my $fig = $self->{_fig};
52 :    
53 :     my %constraints = map { $_ => 1 } @constraints;
54 :     my @genomes = ();
55 :    
56 :     if ($constraints{complete})
57 :     {
58 :     @genomes = $fig->genomes('complete');
59 :     }
60 :     else
61 :     {
62 :     @genomes = $fig->genomes;
63 :     }
64 :    
65 :     if ($constraints{prokaryotic})
66 :     {
67 :     @genomes = grep { $fig->is_prokaryotic($_) } @genomes;
68 :     }
69 :    
70 :     if ($constraints{eukaryotic})
71 :     {
72 :     @genomes = grep { $fig->is_eukaryotic($_) } @genomes;
73 :     }
74 :    
75 :     if ($constraints{bacterial})
76 :     {
77 :     @genomes = grep { $fig->is_bacterial($_) } @genomes;
78 :     }
79 :    
80 :     if ($constraints{archaeal})
81 :     {
82 :     @genomes = grep { $fig->is_archaeal($_) } @genomes;
83 :     }
84 :    
85 :     if ($constraints{nmpdr})
86 :     {
87 :     @genomes = grep { $fig->is_NMPDR_genome($_) } @genomes;
88 :     }
89 :    
90 :     return map { &GenomeO::new('GenomeO',$self,$_) } @genomes;
91 :     }
92 :    
93 :     sub subsystems {
94 :     my($self) = @_;
95 :     my $fig = $self->{_fig};
96 :    
97 :     return map { &SubsystemO::new('SubsystemO',$self,$_) } $fig->all_subsystems;
98 :     }
99 :    
100 :     sub functional_roles {
101 :     my($self) = @_;
102 :     my $fig = $self->{_fig};
103 :    
104 :     my @functional_roles = ();
105 :    
106 :     return @functional_roles;
107 :     }
108 :    
109 :     sub all_figfams {
110 :     my($self) = @_;
111 :     my $fig = $self->{_fig};
112 :     my $fams = new FigFams($fig);
113 :     return map { &FigFamO::new('FigFamO',$self,$_) } $fams->all_families;
114 :     }
115 :    
116 :     sub family_containing {
117 :     my($self,$seq) = @_;
118 :    
119 :     my $fig = $self->{_fig};
120 :     my $fams = new FigFams($fig);
121 :     my($fam,$sims) = $fams->place_in_family($seq);
122 :     if ($fam)
123 :     {
124 :     return (&FigFamO::new('FigFamO',$self,$fam->family_id),$sims);
125 :     }
126 :     else
127 :     {
128 :     return undef;
129 :     }
130 :     }
131 :    
132 :     package GenomeO;
133 :    
134 :     use Data::Dumper;
135 :    
136 :     sub new {
137 :     my($class,$figO,$genomeId) = @_;
138 :    
139 :     my $self = {};
140 :     $self->{_figO} = $figO;
141 :     $self->{_id} = $genomeId;
142 :     return bless $self, $class;
143 :     }
144 :    
145 :     sub id {
146 :     my($self) = @_;
147 :    
148 :     return $self->{_id};
149 :     }
150 :    
151 :     sub genus_species {
152 :     my($self) = @_;
153 :    
154 :     my $fig = $self->{_figO}->{_fig};
155 :     return $fig->genus_species($self->{_id});
156 :     }
157 :    
158 :     sub contigs_of {
159 :     my($self) = @_;
160 :    
161 :     my $figO = $self->{_figO};
162 :     my $fig = $figO->{_fig};
163 :     return map { &ContigO::new('ContigO',$figO,$self->id,$_) } $fig->contigs_of($self->id);
164 :     }
165 :    
166 :     sub features_of {
167 :     my($self,$type) = @_;
168 :    
169 :     my $figO = $self->{_figO};
170 :     my $fig = $figO->{_fig};
171 :    
172 :     return map { &FeatureO::new('FeatureO',$figO,$_) } $fig->all_features($self->id,$type);
173 :     }
174 :    
175 :     sub display {
176 :     my($self) = @_;
177 :    
178 :     print join("\t",("Genome",$self->id,$self->genus_species)),"\n";
179 :     }
180 :    
181 :     package ContigO;
182 :    
183 :     use Data::Dumper;
184 :    
185 :     sub new {
186 :     my($class,$figO,$genomeId,$contigId) = @_;
187 :    
188 :     my $self = {};
189 :     $self->{_figO} = $figO;
190 :     $self->{_id} = $contigId;
191 :     $self->{_genome} = $genomeId;
192 :     return bless $self, $class;
193 :     }
194 :    
195 :     sub id {
196 :     my($self) = @_;
197 :    
198 :     return $self->{_id};
199 :     }
200 :    
201 :     sub genome {
202 :     my($self) = @_;
203 :    
204 :     return $self->{_genome};
205 :     }
206 :    
207 :     sub contig_length {
208 :     my($self) = @_;
209 :    
210 :     my $fig = $self->{_figO}->{_fig};
211 :     my $contig_lengths = $fig->contig_lengths($self->genome);
212 :     return $contig_lengths->{$self->id};
213 :     }
214 :    
215 :     sub dna_seq {
216 :     my($self,$beg,$end) = @_;
217 :    
218 :     my $fig = $self->{_figO}->{_fig};
219 :     my $max = $self->contig_length;
220 :     if (($beg && (&FIG::between(1,$beg,$max))) &&
221 :     ($end && (&FIG::between(1,$end,$max))))
222 :     {
223 :     return $fig->dna_seq($self->genome,join("_",($self->id,$beg,$end)));
224 :     }
225 :     else
226 :     {
227 :     return undef;
228 :     }
229 :     }
230 :    
231 :     sub display {
232 :     my($self) = @_;
233 :    
234 :     print join("ContigO",$self->genome,$self->id,$self->contig_length),"\n";
235 :     }
236 :    
237 :     package FeatureO;
238 :    
239 :     use Data::Dumper;
240 :    
241 :     sub new {
242 :     my($class,$figO,$fid) = @_;
243 :    
244 :     ($fid =~ /^fig\|\d+\.\d+\.[^\.]+\.\d+$/) || return undef;
245 :     my $self = {};
246 :     $self->{_figO} = $figO;
247 :     $self->{_id} = $fid;
248 :     return bless $self, $class;
249 :     }
250 :    
251 :     sub id {
252 :     my($self) = @_;
253 :    
254 :     return $self->{_id};
255 :     }
256 :    
257 :     sub genome {
258 :     my($self) = @_;
259 :    
260 :     $self->id =~ /^fig\|(\d+\.\d+)/;
261 :     return $1;
262 :     }
263 :    
264 :     sub type {
265 :     my($self) = @_;
266 :    
267 :     $self->id =~ /^fig\|\d+\.\d+\.([^\.]+)/;
268 :     return $1;
269 :     }
270 :    
271 :     sub location {
272 :     my($self) = @_;
273 :    
274 :     my $fig = $self->{_figO}->{_fig};
275 :     return scalar $fig->feature_location($self->id);
276 :     }
277 :    
278 :     sub dna_seq {
279 :     my($self) = @_;
280 :    
281 :     my $fig = $self->{_figO}->{_fig};
282 :     my $fid = $self->id;
283 :     my @loc = $fig->feature_location($fid);
284 :     return $fig->dna_seq(&FIG::genome_of($fid),@loc);
285 :     }
286 :    
287 :     sub prot_seq {
288 :     my($self) = @_;
289 :    
290 :     ($self->type eq "peg") || return undef;
291 :     my $fig = $self->{_figO}->{_fig};
292 :     my $fid = $self->id;
293 :     return $fig->get_translation($fid);
294 :     }
295 :    
296 :     sub function_of {
297 :     my($self) = @_;
298 :    
299 :     my $fig = $self->{_figO}->{_fig};
300 :     my $fid = $self->id;
301 :     return scalar $fig->function_of($fid);
302 :     }
303 :    
304 :     sub coupled_to {
305 :     my($self) = @_;
306 :    
307 :     ($self->type eq "peg") || return undef;
308 :     my $figO = $self->{_figO};
309 :     my $fig = $figO->{_fig};
310 :     my $peg1 = $self->id;
311 :     my @coupled = ();
312 :     foreach my $tuple ($fig->coupled_to($peg1))
313 :     {
314 :     my($peg2,$sc) = @$tuple;
315 :     push(@coupled, &CouplingO::new('CouplingO',$figO,$peg1,$peg2,$sc));
316 :     }
317 :     return @coupled;
318 :     }
319 :    
320 :     sub annotations {
321 :     my($self) = @_;
322 :    
323 :     my $figO = $self->{_figO};
324 :     my $fig = $figO->{_fig};
325 :    
326 :     return map { &AnnotationO::new('AnnotationO',@$_) } $fig->feature_annotations($self->id,1);
327 :     }
328 :    
329 : overbeek 1.3 sub possibly_truncated {
330 :     my($self) = @_;
331 :     my $figO = $self->{_figO};
332 :     my $fig = $figO->{_fig};
333 :    
334 :     return $fig->possibly_truncated($self->id);
335 :     }
336 :    
337 :     sub possible_frameshift {
338 :     my($self) = @_;
339 :     my $figO = $self->{_figO};
340 :     my($tmp_dir) = $figO->{_tmp_dir};
341 :    
342 :     if (! $self->possibly_truncated)
343 :     {
344 :     my @sims = $self->sims( -max => 1, -cutoff => 1.0e-50);
345 :     if (my $sim = shift @sims)
346 :     {
347 :     my $peg2 = $sim->id2;
348 :     my $ln1 = $sim->ln1;
349 :     my $ln2 = $sim->ln2;
350 :     my $b2 = $sim->b2;
351 :     my $e2 = $sim->e2;
352 :     my $adjL = 100 + (($b2-1) * 3);
353 :     my $adjR = 100 + (($ln2 - $e2) * 3);
354 :     if ($ln2 > (1.2 * $ln1))
355 :     {
356 :     my $loc = $self->location;
357 :     if ($loc =~ /^(\S+)_(\d+)_(\d+)/)
358 :     {
359 :     my $contig = $1;
360 :     my $beg = $2;
361 :     my $end = $3;
362 :     my $contigO = new ContigO($figO,$self->genome,$contig);
363 :     my $begA = &max(1,$beg - $adjL);
364 :     my $endA = &min($end+$adjR,$contigO->contig_length);
365 :     my $dna = $contigO->dna_seq($begA,$endA);
366 :     open(TMP,">$tmp_dir/tmp_dna") || die "couild not open tmp_dna";
367 :     print TMP ">dna\n$dna\n";
368 :     close(TMP);
369 :    
370 :     my $peg2O = new FeatureO($figO,$peg2);
371 :     my $prot = $peg2O->prot_seq;
372 :     open(TMP,">$tmp_dir/tmp_prot") || die "could not open tmp_prot";
373 :     print TMP ">tmp_prot\n$prot\n";
374 :     close(TMP);
375 :     &run("formatdb -i $tmp_dir/tmp_dna -pF");
376 :     open(BLAST,"blastall -i $tmp_dir/tmp_prot -d $tmp_dir/tmp_dna -p tblastn -FF -e 1.0e-50 |")
377 :     || die "could not blast";
378 :    
379 :     my $db_seq_out = &gjoparseblast::next_blast_subject(\*BLAST,1);
380 :     my @hsps = sort { $a->[0] <=> $b->[0] }
381 :     map { [$_->[9],$_->[10],$_->[12],$_->[13]] }
382 :     grep { $_->[1] < 1.0e-50 }
383 :     @{$db_seq_out->[6]};
384 :     my @prot = map { [$_->[0],$_->[1]] } @hsps;
385 :     my @dna = map { [$_->[2],$_->[3]] } @hsps;
386 :     if (&covers(\@prot,length($prot),3) && &covers(\@dna,3*length($prot),9))
387 :     {
388 :     return 1;
389 :     }
390 :     }
391 :     }
392 :     }
393 :     }
394 :     return 0;
395 :     }
396 :    
397 :     sub run {
398 :     my($cmd) = @_;
399 :     (system($cmd) == 0) || Confess("FAILED: $cmd");
400 :     }
401 :    
402 :     sub max {
403 :     my($x,$y) = @_;
404 :     return ($x < $y) ? $y : $x;
405 :     }
406 :    
407 :     sub min {
408 :     my($x,$y) = @_;
409 :     return ($x < $y) ? $x : $y;
410 :     }
411 :    
412 :     sub covers {
413 :     my($hsps,$ln,$diff) = @_;
414 :    
415 :     my $hsp1 = shift @$hsps;
416 :     my $hsp2;
417 :     while ($hsp1 && ($hsp2 = shift @$hsps) && ($hsp1 = &merge($hsp1,$hsp2,$diff))) {}
418 :     return ($hsp1 && (($hsp1->[1] - $hsp1->[0]) > (0.9 * $ln)));
419 :     }
420 :    
421 :     sub merge {
422 :     my($hsp1,$hsp2,$diff) = @_;
423 :    
424 :     my($b1,$e1) = @$hsp1;
425 :     my($b2,$e2) = @$hsp2;
426 :     return (($e2 > $e1) && (abs($b2-$e1) <= $diff)) ? [$b1,$e2] : undef;
427 :     }
428 :    
429 : overbeek 1.2 use Sim;
430 :     sub sims {
431 :     my($self,%args) = @_;
432 :    
433 :     my $figO = $self->{_figO};
434 :     my $fig = $figO->{_fig};
435 :    
436 :     my $cutoff = $args{-cutoff} ? $args{-cutoff} : 1.0e-5;
437 :     my $all = $args{-all} ? $args{-all} : "fig";
438 :     my $max = $args{-max} ? $args{-max} : 10000;
439 :    
440 :     return $fig->sims($self->id,$max,$cutoff,$all);
441 :     }
442 :    
443 :     sub bbhs {
444 :     my($self) = @_;
445 :    
446 :     my $figO = $self->{_figO};
447 :     my $fig = $figO->{_fig};
448 :    
449 :     my @bbhs = $fig->bbhs($self->id);
450 :     return map { my($peg2,$sc,$bs) = @$_; bless({ _peg1 => $self->id,
451 :     _peg2 => $peg2,
452 :     _psc => $sc,
453 :     _bit_score => $bs
454 :     },'BBHO') } @bbhs;
455 :     }
456 :    
457 : overbeek 1.1 sub display {
458 :     my($self) = @_;
459 :    
460 :     print join("\t",$self->id,$self->location,$self->function_of),"\n",
461 :     $self->dna_seq,"\n",
462 :     $self->prot_seq,"\n";
463 :     }
464 :    
465 : overbeek 1.2 package BBHO;
466 :    
467 :     sub new {
468 :     my($class,$peg1,$peg2,$sc,$normalized_bitscore) = @_;
469 :    
470 :     my $self = {};
471 :     $self->{_peg1} = $peg1;
472 :     $self->{_peg2} = $peg2;
473 :     $self->{_psc} = $sc;
474 :     $self->{_bit_score} = $normalized_bitscore
475 :    
476 :     }
477 :    
478 :     sub peg1 {
479 :     my($self) = @_;
480 :    
481 :     return $self->{_peg1};
482 :     }
483 :    
484 :     sub peg2 {
485 :     my($self) = @_;
486 :    
487 :     return $self->{_peg2};
488 :     }
489 :    
490 :     sub psc {
491 :     my($self) = @_;
492 :    
493 :     return $self->{_psc};
494 :     }
495 :    
496 :     sub norm_bitscore {
497 :     my($self) = @_;
498 :    
499 :     return $self->{_bit_score};
500 :     }
501 :    
502 : overbeek 1.1 package AnnotationO;
503 :    
504 :     sub new {
505 :     my($class,$fid,$timestamp,$who,$text) = @_;
506 :    
507 :     my $self = {};
508 :     $self->{_fid} = $fid;
509 :     $self->{_timestamp} = $timestamp;
510 :     $self->{_who} = $who;
511 :     $self->{_text} = $text;
512 :     return bless $self, $class;
513 :     }
514 :    
515 :     sub fid {
516 :     my($self) = @_;
517 :    
518 :     return $self->{_fid};
519 :     }
520 :    
521 :     sub timestamp {
522 :     my($self,$convert) = @_;
523 :    
524 :     if ($convert)
525 :     {
526 :     return scalar localtime($self->{_timestamp});
527 :     }
528 :     else
529 :     {
530 :     return $self->{_timestamp};
531 :     }
532 :     }
533 :    
534 :     sub made_by {
535 :     my($self) = @_;
536 :    
537 :     my $who = $self->{_who};
538 :     $who =~ s/^master://i;
539 :     return $who;
540 :     }
541 :    
542 :     sub text {
543 :     my($self) = @_;
544 :    
545 :     my $text = $self->{_text};
546 :     return $text;
547 :     }
548 :    
549 :     sub display {
550 :     my($self) = @_;
551 :    
552 :     print join("\t",($self->fid,$self->timestamp(1),$self->made_by)),"\n",$self->text,"\n";
553 :     }
554 :    
555 :     package CouplingO;
556 :    
557 :     use Data::Dumper;
558 :    
559 :     sub new {
560 :     my($class,$figO,$peg1,$peg2,$sc) = @_;
561 :    
562 :     ($peg1 =~ /^fig\|\d+\.\d+\.peg\.\d+$/) || return undef;
563 :     ($peg2 =~ /^fig\|\d+\.\d+\.peg\.\d+$/) || return undef;
564 :     my $self = {};
565 :     $self->{_figO} = $figO;
566 :     $self->{_peg1} = $peg1;
567 :     $self->{_peg2} = $peg2;
568 :     $self->{_sc} = $sc;
569 :     return bless $self, $class;
570 :     }
571 :    
572 :     sub peg1 {
573 :     my($self) = @_;
574 :    
575 :     return $self->{_peg1};
576 :     }
577 :    
578 :     sub peg2 {
579 :     my($self) = @_;
580 :    
581 :     return $self->{_peg2};
582 :     }
583 :    
584 :     sub sc {
585 :     my($self) = @_;
586 :    
587 :     return $self->{_sc};
588 :     }
589 :    
590 :     sub evidence {
591 :     my($self) = @_;
592 :    
593 :     my $figO = $self->{_figO};
594 :     my $fig = $figO->{_fig};
595 :     my @ev = ();
596 :     foreach my $tuple ($fig->coupling_evidence($self->peg1,$self->peg2))
597 :     {
598 :     my($peg3,$peg4,$rep) = @$tuple;
599 :     push(@ev,[&FeatureO::new('FeatureO',$figO,$peg3),
600 :     &FeatureO::new('FeatureO',$figO,$peg4),
601 :     $rep]);
602 :     }
603 :     return @ev;
604 :     }
605 :    
606 :     sub display {
607 :     my($self) = @_;
608 :    
609 :     print join("\t",($self->peg1,$self->peg2,$self->sc)),"\n";
610 :     }
611 :    
612 :     package SubsystemO;
613 :    
614 :     use Data::Dumper;
615 :     use Subsystem;
616 :    
617 :     sub new {
618 :     my($class,$figO,$name) = @_;
619 :    
620 :     my $self = {};
621 :     $self->{_figO} = $figO;
622 :     $self->{_id} = $name;
623 :    
624 :     return bless $self, $class;
625 :     }
626 :    
627 :     sub id {
628 :     my($self) = @_;
629 :    
630 :     return $self->{_id};
631 :     }
632 :    
633 :     sub usable {
634 :     my($self) = @_;
635 :    
636 :     my $figO = $self->{_figO};
637 :     my $fig = $figO->{_fig};
638 :     return $fig->usable_subsystem($self->id);
639 :     }
640 :    
641 :     sub genomes {
642 :     my($self) = @_;
643 :    
644 :     my $figO = $self->{_figO};
645 :     my $subO = $self->{_subO};
646 :     if (! $subO) { $subO = $self->{_subO} = new Subsystem($self->{_id},$figO->{_fig}); }
647 :    
648 :     return map { &GenomeO::new('GenomeO',$figO,$_) } $subO->get_genomes;
649 :     }
650 :    
651 :     sub roles {
652 :     my($self) = @_;
653 :    
654 :     my $figO = $self->{_figO};
655 :     my $subO = $self->{_subO};
656 :     if (! $subO) { $subO = $self->{_subO} = new Subsystem($self->{_id},$figO->{_fig}); }
657 :    
658 :     return map { &FunctionalRoleO::new('FunctionalRoleO',$figO,$_) } $subO->get_roles($self->id);
659 :     }
660 :    
661 :     sub curator {
662 :     my($self) = @_;
663 :    
664 :     my $figO = $self->{_figO};
665 :     my $subO = $self->{_subO};
666 :     if (! $subO) { $subO = $self->{_subO} = new Subsystem($self->{_id},$figO->{_fig}); }
667 :    
668 :     return $subO->get_curator;
669 :     }
670 :    
671 :     sub variant {
672 :     my($self,$genome) = @_;
673 :    
674 :     my $figO = $self->{_figO};
675 :     my $subO = $self->{_subO};
676 :     if (! $subO) { $subO = $self->{_subO} = new Subsystem($self->{_id},$figO->{_fig}); }
677 :    
678 :     return $subO->get_variant_code_for_genome($genome->id);
679 :     }
680 :    
681 :     sub pegs_in_cell {
682 :     my($self,$genome,$role) = @_;
683 :    
684 :     my $figO = $self->{_figO};
685 :     my $subO = $self->{_subO};
686 :     if (! $subO) { $subO = $self->{_subO} = new Subsystem($self->{_id},$figO->{_fig}); }
687 :    
688 :     return $subO->get_pegs_from_cell($genome->id,$role->id);
689 :     }
690 :    
691 :     package FunctionalRoleO;
692 :    
693 :     use Data::Dumper;
694 :    
695 :     sub new {
696 :     my($class,$figO,$fr) = @_;
697 :    
698 :     my $self = {};
699 :     $self->{_figO} = $figO;
700 :     $self->{_id} = $fr;
701 :     return bless $self, $class;
702 :     }
703 :    
704 :     sub id {
705 :     my($self) = @_;
706 :    
707 :     return $self->{_id};
708 :     }
709 :    
710 :     package FigFamO;
711 :    
712 :     use FigFams;
713 :     use FigFam;
714 :    
715 :     sub new {
716 :     my($class,$figO,$id) = @_;
717 :    
718 :     my $self = {};
719 :     $self->{_figO} = $figO;
720 :     $self->{_id} = $id;
721 :     return bless $self, $class;
722 :     }
723 :    
724 :     sub id {
725 :     my($self) = @_;
726 :    
727 :     return $self->{_id};
728 :     }
729 :    
730 :     sub function {
731 :     my($self) = @_;
732 :    
733 :     my $fig = $self->{_figO}->{_fig};
734 :     my $famO = $self->{_famO};
735 :     if (! $famO) { $famO = $self->{_famO} = &FigFam::new('FigFam',$fig,$self->id) }
736 :    
737 :     return $famO->family_function;
738 :     }
739 :    
740 :     sub members {
741 :     my($self) = @_;
742 :    
743 :     my $figO = $self->{_figO};
744 :     my $fig = $figO->{_fig};
745 :     my $famO = $self->{_famO};
746 :     if (! $famO) { $famO = $self->{_famO} = &FigFam::new('FigFam',$fig,$self->id) }
747 :    
748 :     return map { &FigFamO::new('FigFamO',$figO,$_) } $famO->list_members;
749 :     }
750 :    
751 :     sub rep_seqs {
752 :     my($self) = @_;
753 :    
754 :     my $figO = $self->{_figO};
755 :     my $fig = $figO->{_fig};
756 :     my $famO = $self->{_famO};
757 :     if (! $famO) { $famO = $self->{_famO} = &FigFam::new('FigFam',$fig,$self->id) }
758 :    
759 :     return $famO->representatives;
760 :     }
761 :    
762 :     sub should_be_member {
763 :     my($self,$seq) = @_;
764 :    
765 :     my $figO = $self->{_figO};
766 :     my $fig = $figO->{_fig};
767 :     my $famO = $self->{_famO};
768 :     if (! $famO) { $famO = $self->{_famO} = &FigFam::new('FigFam',$fig,$self->id) }
769 :    
770 :     return $famO->should_be_member($seq);
771 :     }
772 :    
773 :    
774 :    
775 :     sub display {
776 :     my($self) = @_;
777 :    
778 :     print join("\t",($self->id,$self->function)),"\n";
779 :     }
780 :    
781 :    
782 :    
783 :     package Attribute;
784 :    
785 :     1;

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3