[Bio] / DeJonghStuff / load_kegg.pl Repository:
ViewVC logotype

Annotation of /DeJonghStuff/load_kegg.pl

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : dejongh 1.1
2 :     # -*- perl -*-
3 :    
4 :     ###########################################
5 :     use strict;
6 :    
7 :     # KEY RELATIONAL TABLES:
8 :     #
9 :     # 1. compound(Cid,Priority,Name) % we have a prioritized set of names for a compound
10 :     # 2. comp_to_CAS(Cid,CASid) % connection to chemical abstract society [optional]
11 :     # 3. reaction(Rid,Reversible) % nonreversible go from substrates to products
12 :     # 4. reaction_to_compound(Rid,0/1[substrate or product],Cid,Stoich,main_compound [part of major transformation])
13 :     # 5. reaction_to_role(Rid,FunctionalRole)
14 :     #
15 :    
16 :     use FIG;
17 :     my $fig = new FIG;
18 :    
19 :     my $usage = "usage: load_kegg";
20 :    
21 :     use Tracer;
22 : dejongh 1.2 #TSetup('2 *', 'WARN');
23 : dejongh 1.1 &load_ec_and_map_data;
24 :     &load_compounds;
25 :     &load_reactions;
26 :     &load_catalyzes;
27 :    
28 :     undef $fig;
29 :    
30 :     sub load_ec_and_map_data {
31 :    
32 :     Open(\*TMPIN, "<$FIG_Config::data/KEGG/enzyme");
33 :     Open(\*ECMAP,">$FIG_Config::temp/ec_map.table");
34 :    
35 :     Trace("Reading KEGG enzymes.") if T(2);
36 :     my($ec,%name,$map);
37 :     $/ = "\n///\n";
38 :     while (defined($_ = <TMPIN>))
39 :     {
40 :     if ($_ =~ /ENTRY\s+EC\s+(\d+\.\d+\.\d+\.\d+)/s)
41 :     {
42 :     $ec = $1;
43 :     while ($_ =~ /PATH:\s+(map\d+)\s+(\S[^\n]+\S)/sg)
44 :     {
45 : dejongh 1.2 print ECMAP "$ec\t$1\n";
46 : dejongh 1.1 $name{$1} = $2;
47 :     }
48 :     }
49 :     }
50 :     $/ = "\n";
51 :     close(TMPIN);
52 :     close(ECMAP);
53 :    
54 :     Trace("Writing map table.") if T(2);
55 :     Open(\*MAP, ">$FIG_Config::temp/map_name.table");
56 :    
57 :     foreach $map (keys(%name))
58 :     {
59 :     print MAP "$map\t$name{$map}\n";
60 :     }
61 :     close(MAP);
62 :    
63 :     $fig->reload_table('all', "ec_map",
64 :     "ec varchar(100), map varchar(100)",
65 :     { index_ec_map_ec => "ec", index_ec_map_map => "map" },
66 :     "$FIG_Config::temp/ec_map.table");
67 :     unlink("$FIG_Config::temp/ec_map.table");
68 :     $fig->reload_table('all', "map_name",
69 :     "map varchar(100) UNIQUE NOT NULL, mapname varchar(200), primary key ( map )",
70 :     { }, "$FIG_Config::temp/map_name.table");
71 :     unlink("$FIG_Config::temp/map_name.table");
72 :     }
73 :    
74 :     sub load_compounds {
75 :    
76 :     Trace("Loading compounds.") if T(2);
77 :    
78 :     Open(\*TMPIN, "<$FIG_Config::data/KEGG/compound");
79 :     Open(\*COMP, ">$FIG_Config::temp/comp_name.table");
80 :     Open(\*CAS, ">$FIG_Config::temp/comp_cas.table");
81 :    
82 :     my($cid,$name,$cas,$names,$tmp,$n,$entry);
83 :     $/ = "\n///\n";
84 :     while (defined($entry = <TMPIN>))
85 :     {
86 : dejongh 1.3 if ($entry =~ /ENTRY\s+(C\d+).*\nNAME\s+(\S[^\n]*)\n((\s+(\S[^\n]*\S)\n)*)/s)
87 : dejongh 1.1 {
88 :     $cid = $1;
89 :     $names = $2;
90 :    
91 :     if ($3)
92 :     {
93 :     $tmp = $3;
94 :     chop $tmp;
95 :     $tmp =~ s/^\s+/ /;
96 :     $names = $names . $tmp;
97 :     $names =~ s/\n\s+/ /g;
98 :     $names =~ s/- /-/g;
99 :     }
100 :    
101 :     $n = 1;
102 :     foreach $name (map { $_ =~ s/^\s+//; $_ =~ s/\s+$//; $_ } split(/;/,$names))
103 :     {
104 :     print COMP "$cid\t$n\t$name\n";
105 :     $n++;
106 :     if (length $name > 200) { print "$cid, $name\n" }
107 :     }
108 :     }
109 :    
110 :     if ($entry =~ /DBLINKS\s+CAS:\s+(\S+)/s)
111 :     {
112 :     print CAS "$cid\t$1\n";
113 :     }
114 :     }
115 :     $/ = "\n";
116 :     close(TMPIN);
117 :     close(COMP);
118 :     close(CAS);
119 :    
120 :     $fig->reload_table('all', "comp_name",
121 :     "cid varchar(7), pos integer, name varchar(200)",
122 :     { index_comp_name_cid => "cid",
123 :     index_comp_name_name => "name" },
124 :     "$FIG_Config::temp/comp_name.table");
125 :     unlink("$FIG_Config::temp/comp_name.table");
126 :    
127 :     $fig->reload_table('all', "comp_cas",
128 :     "cid varchar(7), cas varchar(100)",
129 :     { index_comp_cas_cid => "cid",
130 :     index_comp_cas_cas => "cas" },
131 :     "$FIG_Config::temp/comp_cas.table");
132 :     unlink("$FIG_Config::temp/comp_cas.table");
133 :     }
134 :    
135 :     sub load_reactions {
136 :    
137 :     my($react,$sub,$prod,@sub,@prod,$subs,$prods,$dir);
138 :     my($cid,$n,$main,%reaction,$x);
139 :    
140 :     Trace("Loading reactions.") if T(2);
141 :     Open(\*REACTION, "<$FIG_Config::data/KEGG/reaction.lst");
142 :     Open(\*RMAIN, "<$FIG_Config::data/KEGG/reaction_main.lst");
143 :     Open(\*R2C, ">$FIG_Config::temp/reaction_to_compound.table");
144 :     Open(\*REV, ">$FIG_Config::temp/rev.table");
145 :    
146 :     Trace("Reading reaction list file.") if T(2);
147 :     while (defined($_ = <REACTION>))
148 :     {
149 :     if ($_ =~ /(R\d+):\s+(\S.*\S)\s+<=>\s+(\S.*\S)/)
150 :     {
151 :     $react = $1;
152 :     $sub = $2;
153 :     $prod = $3;
154 :     @sub = split(/\s+\+\s+/,$sub);
155 :     @prod = split(/\s+\+\s+/,$prod);
156 :     @sub = map { $_ =~ /^(([\dmn\(]\S*)\s+)?([CG]\d+)/; $2 ? [$3,$2,0] : [$3,1,0] } @sub;
157 :     @prod = map { $_ =~ /^(([\dmn\(]\S*)\s+)?([CG]\d+)/; $2 ? [$3,$2,0] : [$3,1,0] } @prod;
158 :     $reaction{$react} = [[@sub],[@prod]];
159 :     }
160 :     else
161 :     {
162 :     Trace("Invalid reaction format: $_") if T(1);
163 :     }
164 :     }
165 :     close(REACTION);
166 :    
167 :     Trace("Reading main reaction file.") if T(2);
168 :     while (defined($_ = <RMAIN>))
169 :     {
170 :     if ($_ =~ /^(R\d+):\s+(\S.*\S)\s(\<?=\>?)\s(\S.*\S)/)
171 :     {
172 :     $react = $1;
173 :     $sub = $2;
174 :     $dir = $3;
175 :     $prod = $4;
176 :    
177 :     if (exists($reaction{$react}))
178 :     {
179 :     $subs = $reaction{$react}->[0];
180 :     $prods = $reaction{$react}->[1];
181 :     &mark_main($sub,$subs);
182 :     &mark_main($prod,$prods);
183 :     if (($dir eq "<=") || ($dir eq "=>"))
184 :     {
185 :     print REV "$react\t0\n";
186 :     }
187 :    
188 :     if ($dir eq "<=")
189 :     {
190 :     $reaction{$react}->[0] = $prods;
191 :     $reaction{$react}->[1] = $subs;
192 :     }
193 :     }
194 :     }
195 :     }
196 :     close(RMAIN);
197 :     close(REV);
198 :    
199 :     Trace("Connecting reactions to compounds.") if T(2);
200 :     foreach $react (sort keys(%reaction))
201 :     {
202 :     ($subs,$prods) = @{$reaction{$react}};
203 :     foreach $x (@$subs)
204 :     {
205 :     ($cid,$n,$main) = @$x;
206 :     print R2C "$react\t0\t$cid\t$n\t$main\n";
207 :     }
208 :    
209 :     foreach $x (@$prods)
210 :     {
211 :     ($cid,$n,$main) = @$x;
212 :     print R2C "$react\t1\t$cid\t$n\t$main\n";
213 :     }
214 :     }
215 :     close(R2C);
216 :    
217 :     $fig->reload_table('all', "reaction_to_compound",
218 :     "rid varchar(8), setn char(1), cid varchar(8), stoich char(6), main char(1)",
219 :     { index_reaction_to_compound_rid => "rid",
220 :     index_reaction_to_compound_cid => "cid" },
221 :     "$FIG_Config::temp/reaction_to_compound.table");
222 :     unlink("$FIG_Config::temp/reaction_to_compound.table");
223 :    
224 :     $fig->reload_table('all', "reversible",
225 :     "rid varchar(8) UNIQUE NOT NULL, reversible char(1), primary key(rid)",
226 :     { }, "$FIG_Config::temp/rev.table");
227 :     unlink("$FIG_Config::temp/rev.table");
228 :     Trace("Reactions processed.") if T(2);
229 :     }
230 :    
231 :     sub mark_main {
232 :     my($main,$set) = @_;
233 :     my($cid,$i);
234 :    
235 :     foreach $cid (split(/\s+\+\s+/,$main))
236 :     {
237 :     for ($i=0; ($i < @$set) && ($set->[$i]->[0] ne $cid); $i++) {}
238 :     if ($i == @$set)
239 :     {
240 :     Confess("Cannot handle $cid in $_\n" . Dumper($set));
241 :     }
242 :     else
243 :     {
244 :     $set->[$i]->[2] = 1;
245 :     }
246 :     }
247 :     }
248 :    
249 :     sub load_catalyzes {
250 :    
251 :     my($entry);
252 :     Open(\*REAC, "<$FIG_Config::data/KEGG/reaction");
253 :     Open(\*REAC2ENZ, ">$FIG_Config::temp/reaction_to_enzyme.table");
254 :    
255 :     Trace("Reading KEGG reaction file.") if T(2);
256 :     my($rid,$ec,@ecs,$ecs);
257 :     $/ = "\n///\n";
258 :     while (defined($entry = <REAC>))
259 :     {
260 :     if ($entry =~ /ENTRY\s+(R\d+).*\nENZYME\s+(\S[^a-zA-Z\/]+)/s)
261 :     {
262 :     $rid = $1;
263 :     $ecs = $2;
264 :     print "$ecs\n";
265 :     foreach $ec (split(/\s+/,$ecs))
266 :     {
267 :     print REAC2ENZ "$rid\t$ec\n";
268 :     }
269 :     }
270 :     }
271 :     $/ = "\n";
272 :     close(REAC);
273 :     close(REAC2ENZ);
274 :    
275 :     $fig->reload_table('all', "reaction_to_enzyme",
276 :     "rid varchar(8), role varchar(100)",
277 :     { index_reaction_to_enzyme_rid => "rid",
278 :     index_reaction_to_enzyme_role => "role" },
279 :     "$FIG_Config::temp/reaction_to_enzyme.table");
280 :     unlink("$FIG_Config::temp/reaction_to_enzyme.table");
281 :     Trace("Enzyme reactions loaded.") if T(2);
282 :     }

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3