[Bio] / Sprout / ModelSaplingLoader.pm Repository:
ViewVC logotype

Annotation of /Sprout/ModelSaplingLoader.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : parrello 1.1 #!/usr/bin/perl -w
2 :    
3 :     #
4 :     # Copyright (c) 2003-2006 University of Chicago and Fellowship
5 :     # for Interpretations of Genomes. All Rights Reserved.
6 :     #
7 :     # This file is part of the SEED Toolkit.
8 :     #
9 :     # The SEED Toolkit is free software. You can redistribute
10 :     # it and/or modify it under the terms of the SEED Toolkit
11 :     # Public License.
12 :     #
13 :     # You should have received a copy of the SEED Toolkit Public License
14 :     # along with this program; if not write to the University of Chicago
15 :     # at info@ci.uchicago.edu or the Fellowship for Interpretation of
16 :     # Genomes at veronika@thefig.info or download a copy from
17 :     # http://www.theseed.org/LICENSE.TXT.
18 :     #
19 : parrello 1.13 #use FIGMODEL;
20 : parrello 1.1
21 :     package ModelSaplingLoader;
22 :     use strict;
23 :     use Tracer;
24 :     use ERDB;
25 :     use base 'BaseSaplingLoader';
26 :    
27 : parrello 1.14 =head1 Sapling Model Load Group Class
28 : parrello 1.1
29 :     =head2 Introduction
30 :    
31 : parrello 1.14 The Model Load Group includes a small set of tables that describe reactions and compounds
32 :     and how they relate to the models in the main model database.
33 : parrello 1.1
34 :     =head3 new
35 :    
36 : parrello 1.14 my $sl = ModelSaplingLoader->new($erdb, $options, @tables);
37 : parrello 1.1
38 : parrello 1.14 Construct a new ModelSaplingLoader object.
39 : parrello 1.1
40 :     =over 4
41 :    
42 :     =item erdb
43 :    
44 : parrello 1.4 L<Sapling> object for the database being loaded.
45 : parrello 1.1
46 :     =item options
47 :    
48 :     Reference to a hash of command-line options.
49 :    
50 :     =item tables
51 :    
52 :     List of tables in this load group.
53 :    
54 :     =back
55 :    
56 :     =cut
57 :    
58 :     sub new {
59 :     # Get the parameters.
60 :     my ($class, $erdb, $options) = @_;
61 :     # Create the table list.
62 : parrello 1.14 my @tables = qw(Compound Reaction EcNumber Model Media IsTriggeredBy
63 :     IsCategorizedInto IsConsistentWith IsModeledBy Involves
64 :     IsRequiredBy);
65 : parrello 1.1 # Create the BaseSaplingLoader object.
66 :     my $retVal = BaseSaplingLoader::new($class, $erdb, $options, @tables);
67 : parrello 1.14 # Create the reaction tracking hash.
68 :     $retVal->{reactions} = {};
69 : parrello 1.1 # Return it.
70 :     return $retVal;
71 :     }
72 :    
73 :     =head2 Public Methods
74 :    
75 :     =head3 Generate
76 :    
77 :     $sl->Generate();
78 :    
79 : parrello 1.14 Generate the data for the model files.
80 : parrello 1.1
81 :     =cut
82 :    
83 :     sub Generate {
84 :     # Get the parameters.
85 :     my ($self) = @_;
86 :     # Get the database object.
87 :     my $erdb = $self->db();
88 :     # Is this the global section?
89 :     if ($self->global()) {
90 : parrello 1.14 # Load the tables from the model dump files.
91 :     $self->LoadModelFiles();
92 : parrello 1.1 } else {
93 :     # Get the section ID.
94 :     my $genomeID = $self->section();
95 :     #NO GENOME SPECIFIC MODEL STUFF
96 :     }
97 :     }
98 :    
99 : parrello 1.14 =head3 LoadModelFiles
100 : parrello 1.1
101 : parrello 1.14 $sl->LoadModelFiles();
102 : parrello 1.1
103 : parrello 1.14 Load the data from the six model dump files.
104 :    
105 :     =cut
106 :    
107 :     sub LoadModelFiles {
108 :     # Get the parameters.
109 :     my ($self) = @_;
110 :     # Get the model dump file directory.
111 :     my $dir = $self->db()->LoadDirectory() . "/models";
112 :     # First we read the compounds.
113 :     my $ih = $self->CheckFile("$dir/CompoundName.txt", qw(CompoundID Name));
114 :     while (! eof $ih) {
115 :     # Get the next compound.
116 :     my ($id, $label) = $self->ReadLine($ih);
117 :     # Create a compound record for it.
118 :     $self->PutE(Compound => $id, label => $label);
119 :     }
120 :     # Next, the compound-reactions relationship. We create the reactions here, too.
121 :     $ih = $self->CheckFile("$dir/CompoundReaction.txt", qw(CompoundID ReactionID
122 :     Stoichiometry));
123 :     while (! eof $ih) {
124 :     # Get the next link.
125 :     my ($compound, $reaction, $stoich) = $self->ReadLine($ih);
126 :     # Insure the reaction exists.
127 :     $self->CreateReaction($reaction);
128 :     # Check for product or substrate.
129 :     my $product;
130 :     if ($stoich < 0) {
131 :     $product = 0;
132 :     $stoich = -$stoich;
133 :     } else {
134 :     $product = 1;
135 :     }
136 :     # Connect the reaction to the compound.
137 :     $self->PutR(Involves => $reaction, $compound, product => $product,
138 :     stoichiometry => $stoich);
139 :     }
140 :     # Now we connect the reactions to roles.
141 :     $ih = $self->CheckFile("$dir/ReactionRole.txt", qw(ReactionID Role));
142 :     while (! eof $ih) {
143 :     # Get the next reaction/role pair. We don't need to create roles here because
144 :     # they are built in the Feature module.
145 :     my ($reaction, $role) = $self->ReadLine($ih);
146 :     # Insure the reaction exists.
147 :     $self->CreateReaction($reaction);
148 :     # Connect the reaction to the role.
149 :     $self->PutR(IsTriggeredBy => $reaction, $role);
150 :     }
151 :     # Now we create the models.
152 :     $ih = $self->CheckFile("$dir/ModelGenome.txt", qw(ModelID GenomeID));
153 :     while (! eof $ih) {
154 :     # Get the next model.
155 :     my ($model, $genome) = $self->ReadLine($ih);
156 :     # Create the model.
157 :     $self->PutE(Model => $model);
158 :     # Connect it to the genome. Again, the genomes are created elsewhere.
159 :     $self->PutR(IsModeledBy => $genome, $model);
160 :     }
161 :     # Next we connect the reactions to models.
162 :     $ih = $self->CheckFile("$dir/ModelReaction.txt", qw(ModelID ReactionID));
163 :     while (! eof $ih) {
164 :     # Get the next line.
165 :     my ($model, $reaction) = $self->ReadLine($ih);
166 :     # Only proceed if a reaction is present.
167 :     if ($reaction) {
168 :     # Insure the reaction exists.
169 :     $self->CreateReaction($reaction);
170 :     # Connect the reaction to the model.
171 :     $self->PutR(IsRequiredBy => $reaction, $model);
172 : parrello 1.1 }
173 :     }
174 :     }
175 :    
176 : parrello 1.14 =head3 StartFile
177 :    
178 :     my $ih = $sl->CheckFile($fileName, @fieldNames);
179 :    
180 :     Read the header record of the specified file and verify that the field names match
181 :     the names in the input list. If they do not, an error will be thrown; if they do, an
182 :     open file handle will be returned, positioned on the first data record.
183 :    
184 :     =over 4
185 :    
186 :     =item fileName
187 :    
188 :     Name for the input file. The file is in standard tab-delimited format. The first record
189 :     contains the field names and the remaining records contain the data.
190 :    
191 :     =item fieldNames
192 :    
193 :     List of the field names expected, in order.
194 :    
195 :     =item RETURN
196 :    
197 :     Returns the open file handle if successful. If there is a mismatch, throws an error.
198 :    
199 :     =back
200 :    
201 :     =cut
202 :    
203 :     sub CheckFile {
204 :     # Get the parameters.
205 :     my ($self, $fileName, @fieldNames) = @_;
206 :     # Open the file.
207 :     my $retVal = Open(undef, "<$fileName");
208 :     $self->Add(files => 1);
209 :     # Read in the file header.
210 :     my @actualFields = Tracer::GetLine($retVal);
211 :     # This will be set to TRUE if there's a mismatch.
212 :     my $error = 0;
213 :     for (my $i = 0; $i <= $#fieldNames; $i++) {
214 :     if ($fieldNames[$i] ne $actualFields[$i]) {
215 :     Trace("Field match error: expected $fieldNames[$i], found $actualFields[$i].") if T(0);
216 :     $error = 1;
217 : parrello 1.1 }
218 :     }
219 : parrello 1.14 # Was there an error?
220 :     if ($error) {
221 :     # Yes, so abort.
222 :     Confess("Invalid field name header in $fileName.");
223 :     } else {
224 :     # No, so trace the open.
225 :     Trace("Processing $fileName.") if T(ERDBLoadGroup => 2);
226 :     }
227 :     # Return the file handle.
228 :     return $retVal;
229 : parrello 1.1 }
230 :    
231 : parrello 1.14 =head3 ReadLine
232 :    
233 :     my @fields = $sl->ReadLine($ih);
234 : parrello 1.1
235 : parrello 1.14 Read a line of data from an input file.
236 :    
237 :     =over 4
238 :    
239 :     =item ih
240 :    
241 :     Open file handle for the input file.
242 :    
243 :     =item RETURN
244 :    
245 :     Returns a list of the field values for the next record in the file.
246 :    
247 :     =back
248 :    
249 :     =cut
250 :    
251 :     sub ReadLine {
252 :     # Get the parameters.
253 :     my ($self, $ih) = @_;
254 :     # Read the line.
255 :     my @retVal = Tracer::GetLine($ih);
256 :     # Count this record.
257 :     $self->Track(records => $retVal[0], 1000);
258 :     # Return the data.
259 :     return @retVal;
260 :     }
261 :    
262 :    
263 :     =head3 CheckReaction
264 :    
265 :     $sl->CheckReaction($reaction);
266 :    
267 :     Insure we have created a rectord for the specified reaction.
268 :    
269 :     =over 4
270 :    
271 :     =item reaction
272 :    
273 :     ID of the reaction in question.
274 :    
275 :     =back
276 :    
277 :     =cut
278 :    
279 :     sub CreateReaction {
280 :     # Get the parameters.
281 :     my ($self, $reaction) = @_;
282 :     # Get the reaction hash.
283 :     my $reactionH = $self->{reactions};
284 :     # See if this reaction is new.
285 :     if (! $reactionH->{$reaction}) {
286 :     # It is, so create it.
287 :     $self->PutE(Reaction => $reaction);
288 :     # Insure we don't create it again.
289 :     $reactionH->{$reaction} = 1;
290 :     }
291 : parrello 1.10 }
292 :    
293 : parrello 1.1 1;

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3