[Bio] / FortyEight / rp_chunk_sims.pl Repository:
ViewVC logotype

Annotation of /FortyEight/rp_chunk_sims.pl

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : olson 1.1 #
2 :     # Chunk a fasta file into pieces suitable for cluster BLAST calculations.
3 :     #
4 :     # We are provided the NR and peg.synonyms files that should be used for this.
5 :     #
6 :     # Usage: rp_chunk_sims fasta-file nr peg.synonyms sims-job-dir
7 :     #
8 :     # We write a file task.list into sims-job-dir that contains the list of work units.
9 :     #
10 :     # The work units will write raw sims into sims-job-dir/sims.raw
11 :     #
12 :    
13 :     use strict;
14 :     use File::Basename;
15 :     use Cwd 'abs_path';
16 :    
17 : olson 1.5 my $usage = "Usage: $0 [-size max-size] [-include-self] [-self-fasta fasta-file] fasta-file nr peg.synonyms sims-job-dir";
18 : olson 1.3
19 :     my $max_size = 10_000;
20 : olson 1.4 my $include_self = 0;
21 : olson 1.5 my $self_fasta;
22 : olson 1.3
23 :     while (@ARGV > 0 and $ARGV[0] =~ /^-/)
24 :     {
25 :     my $arg = shift @ARGV;
26 :     if ($arg =~ /^-size/)
27 :     {
28 :     $max_size = shift @ARGV;
29 :     }
30 : olson 1.4 elsif ($arg =~ /^-include-self/)
31 :     {
32 :     $include_self++;
33 :     }
34 : olson 1.5 elsif ($arg =~ /^-self-fasta/)
35 :     {
36 :     $self_fasta = shift @ARGV;
37 :     }
38 : olson 1.3 else
39 :     {
40 :     die $usage;
41 :     }
42 :     }
43 :    
44 :     @ARGV == 4 or die $usage;
45 : olson 1.1
46 :     my $fasta = shift;
47 :     my $nr_file = shift;
48 :     my $pegsyn = shift;
49 :     my $jobdir = shift;
50 :    
51 : olson 1.5 if (!defined($self_fasta))
52 :     {
53 :     $self_fasta = $fasta;
54 :     }
55 :    
56 : olson 1.1 -d $jobdir or mkdir $jobdir or die "Cannot mkdir $jobdir: $!\n";
57 :    
58 :     my $next_task = 1;
59 :     my $last_task;
60 :    
61 :     my $task_file = "$jobdir/task.list";
62 :     my $input_dir = "$jobdir/sims.in";
63 :     my $output_dir = "$jobdir/sims.raw";
64 :     my $error_dir = "$jobdir/sims.err";
65 :    
66 :     -d $input_dir or mkdir $input_dir or die "Cannot mkdir $input_dir: $!\n";
67 :     -d $output_dir or mkdir $output_dir or die "Cannot mkdir $output_dir: $!\n";
68 :     -d $error_dir or mkdir $error_dir or die "Cannot mkdir $error_dir: $!\n";
69 :    
70 :     my $flags = "-m 8 -e 1.0e-5 -FF -p blastp";
71 :    
72 :     my @fasta_files = ($fasta);
73 :    
74 :     open(TASK, ">$task_file") or die "Cannot write $task_file: $!";
75 :    
76 :     #
77 :     # Buzz through once to ensure we can open them.
78 :     #
79 : olson 1.5 for my $file (@fasta_files, $self_fasta)
80 : olson 1.1 {
81 :     open(F, "<$file") or die "Cannot open $file: $!\n";
82 :     close(F);
83 :     }
84 :    
85 : olson 1.5
86 :     #
87 :     # Prepare and submit self-sims.
88 :     #
89 :     if ($include_self)
90 :     {
91 :     #
92 :     # hack - leftover from legacy chunking code that wanted multiple
93 :     # directories of sims. we need to direct the output all to the
94 :     # same directory.
95 :     #
96 :     my $base = basename($fasta);
97 :     my $file = abs_path($self_fasta);
98 :    
99 :     system("$FIG_Config::ext_bin/formatdb", "-p", "t", "-i", $file);
100 :     my $task = $next_task++;
101 :     print TASK join("\t", $task, $file, $file, $flags,
102 :     "$output_dir/$base/out.$task", "$error_dir/$base/err.$task"), "\n";
103 :     }
104 :    
105 : olson 1.1 for my $file (@fasta_files)
106 :     {
107 :     my $cur_size = 0;
108 :     my $cur_input = '';
109 :    
110 :     my $base = basename($file);
111 :     $file = abs_path($file);
112 :    
113 :     open(F, "<$file") or die "Cannot open $file: $!\n";
114 :    
115 :     print "Chunk file $file\n";
116 :    
117 :     while (<F>)
118 :     {
119 :     if (/^>/)
120 :     {
121 :     if ($cur_size >= $max_size)
122 :     {
123 :     write_task($base, $input_dir, $output_dir, $error_dir, $cur_input);
124 :     $cur_size = 0;
125 :     $cur_input = '';
126 :     }
127 :     $cur_input .= $_;
128 :     $cur_size += length($_);
129 :     }
130 :     else
131 :     {
132 :     $cur_input .= $_;
133 :     $cur_size += length($_);
134 :     }
135 :     }
136 :     if ($cur_size >= 0)
137 :     {
138 :     write_task($base, $input_dir, $output_dir, $error_dir, $cur_input);
139 :     $cur_size = 0;
140 :     $cur_input = '';
141 :     }
142 :     close(F);
143 :     }
144 : olson 1.4
145 : olson 1.1 close(TASK);
146 :    
147 :     print "tasks\t1\t$last_task\n";
148 :    
149 :     #
150 :     # Write an input chunk to $dir.
151 :     # Write a line on the
152 :     sub write_task
153 :     {
154 :     my($base, $input_dir, $output_dir, $error_dir, $fasta) = @_;
155 :    
156 :     my $task = $next_task++;
157 :    
158 :     my $idir = "$input_dir/$base";
159 :     my $odir = "$output_dir/$base";
160 :     my $edir = "$error_dir/$base";
161 :    
162 :     -d $idir or mkdir($idir) or die "Cannot mkdir $idir: $!\n";
163 :     -d $odir or mkdir($odir) or die "Cannot mkdir $odir: $!\n";
164 :     -d $edir or mkdir($edir) or die "Cannot mkdir $edir: $!\n";
165 :    
166 :     my $in = "$idir/in.$task";
167 :     my $out = "$odir/out.$task";
168 :     my $err = "$edir/err.$task";
169 :    
170 :     open(I, ">$in") or die "Cannot write $in: $!";
171 :     print I $fasta;
172 :     close(I);
173 :     print TASK join("\t", $task, $in, $nr_file, $flags, $out, $err), "\n";
174 :     $last_task = $task;
175 :     }

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3