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

Diff of /FigKernelPackages/FIGMODELmodel.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.5, Mon Mar 8 19:53:15 2010 UTC revision 1.18, Mon May 31 18:05:08 2010 UTC
# Line 1  Line 1 
 package FIGMODELmodel;  
1  use strict;  use strict;
2    package FIGMODELmodel;
3    
4  =head1 FIGMODELmodel object  =head1 FIGMODELmodel object
5  =head2 Introduction  =head2 Introduction
# Line 14  Line 14 
14  =cut  =cut
15  sub new {  sub new {
16          my ($class,$figmodel,$id) = @_;          my ($class,$figmodel,$id) = @_;
17    
18          #Error checking first          #Error checking first
19          if (!defined($figmodel)) {          if (!defined($figmodel)) {
20                  print STDERR "FIGMODELmodel->new(undef,".$id."):figmodel must be defined to create a model object!\n";                  print STDERR "FIGMODELmodel->new(undef,".$id."):figmodel must be defined to create a model object!\n";
# Line 27  Line 28 
28          }          }
29    
30          #Checking that the id exists          #Checking that the id exists
31          my $tbl = $self->figmodel()->database()->GetDBTable("MODELS");          my $modelHandle = $self->figmodel()->database()->get_object_manager("model");
32          if (!defined($tbl)) {          if (!defined($modelHandle)) {
33                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not load MODELS table. Check database!");                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not load MODELS table. Check database!");
34                  return undef;                  return undef;
35          }          }
36    
37          #If the id is a number, we get the model row by index          #If the id is a number, we get the model row by index
         my $index = $id;  
38          if ($id =~ m/^\d+$/) {          if ($id =~ m/^\d+$/) {
39                  $self->{_data} = $tbl->get_row($id);                  my $objects = $modelHandle->get_objects();
40          } else {                  $self->{_data} = $objects->[$id];
41                  $self->{_data} = $tbl->get_row_by_key($id,"id");                  $self->figmodel()->{_models}->{$id} = $self;
42                  if (!defined($self->{_data})) {          } else {
43                          if ($id =~ m/(.+)(V[^V]+)/) {                  my $objects = $modelHandle->get_objects({id => $id});
44                                  $self->{_data} = $tbl->get_row_by_key($1,"id");                  if (!defined($objects->[0]) && $id =~ m/(.+)(V[^V]+)/) {
45                                  if (!defined($self->{_data})) {                          $objects = $modelHandle->get_objects({id => $1});
46                            if (!defined($objects->[0])) {
47                                          $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");                                          $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");
48                                          return undef;                                          return undef;
49                                  }                                  }
50                                  $self->{_selectedversion} = $2;                                  $self->{_selectedversion} = $2;
51                          } else {                  } elsif (!defined($objects->[0])) {
52                                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");                                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");
53                                  return undef;                                  return undef;
54                          }                          }
55                  }                  $self->{_data} = $objects->[0];
                 $index = $tbl->row_index($self->{_data});  
56          }          }
57          if (!defined($self->{_data})) {          if (!defined($self->{_data})) {
58                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find specified id in database!");                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find specified id in database!");
59                  return undef;                  return undef;
60          }          }
         $self->{_index} = $index;  
61          $self->figmodel()->{_models}->{$self->id()} = $self;          $self->figmodel()->{_models}->{$self->id()} = $self;
         $self->figmodel()->{_models}->{$self->index()} = $self;  
62    
63          return $self;          return $self;
64  }  }
# Line 118  Line 116 
116  =cut  =cut
117  sub fig {  sub fig {
118          my ($self) = @_;          my ($self) = @_;
   
119          if (!defined($self->{_fig}) && $self->source() !~ /^MGRAST/) {          if (!defined($self->{_fig}) && $self->source() !~ /^MGRAST/) {
120                  if ($self->source() =~ /^RAST/) {                  if ($self->source() =~ /^RAST/) {
121                          $self->{"_fig"} = $self->figmodel()->fig();#$self->genome());                          $self->{"_fig"} = $self->figmodel()->fig();#$self->genome());
# Line 126  Line 123 
123                          $self->{"_fig"} = $self->figmodel()->fig();                          $self->{"_fig"} = $self->figmodel()->fig();
124                  }                  }
125          }          }
   
126          return $self->{"_fig"};          return $self->{"_fig"};
127  }  }
128    
129    =head3 aquireModelLock
130    
131    Definition:
132    
133            FIGMODELmodel->aquireModelLock();
134    
135    Description:
136    
137            Locks the database for alterations relating to the current model object
138    
139    =cut
140    sub aquireModelLock {
141            my ($self) = @_;
142            $self->figmodel()->database()->genericLock($self->id());
143    }
144    
145    =head3 releaseModelLock
146    
147    Definition:
148    
149            FIGMODELmodel->releaseModelLock();
150    
151    Description:
152    
153            Unlocks the database for alterations relating to the current model object
154    
155    =cut
156    sub releaseModelLock {
157            my ($self) = @_;
158            $self->figmodel()->database()->genericUnlock($self->id());
159    }
160    
161  =head3 mgdata  =head3 mgdata
162  Definition:  Definition:
163          FIGMODEL = FIGMODELmodel->mgdata();          FIGMODEL = FIGMODELmodel->mgdata();
# Line 138  Line 166 
166  =cut  =cut
167  sub mgdata {  sub mgdata {
168          my ($self) = @_;          my ($self) = @_;
   
169          if (!defined($self->{_mgdata}) && $self->source() =~ /^MGRAST/) {          if (!defined($self->{_mgdata}) && $self->source() =~ /^MGRAST/) {
170                  require MGRAST;                  require MGRAST;
171                  $self->{_mgdata} = $self->figmodel()->mgrast()->Job->get_objects( { 'genome_id' => $self->genome() } )                  $self->{_mgdata} = $self->figmodel()->mgrast()->Job->get_objects( { 'genome_id' => $self->genome() } )
172          }          }
   
173          return $self->{_mgdata};          return $self->{_mgdata};
174  }  }
175    
# Line 155  Line 181 
181  =cut  =cut
182  sub id {  sub id {
183          my ($self) = @_;          my ($self) = @_;
184          return $self->{_data}->{id}->[0];          return $self->{_data}->id();
185  }  }
186    
187  =head3 owner  =head3 owner
# Line 166  Line 192 
192  =cut  =cut
193  sub owner {  sub owner {
194          my ($self) = @_;          my ($self) = @_;
195          return $self->{_data}->{owner}->[0];          return $self->{_data}->owner();
 }  
   
 =head3 index  
 Definition:  
         string = FIGMODELmodel->index();  
 Description:  
         Returns model index  
 =cut  
 sub index {  
         my ($self) = @_;  
         return $self->{_index};  
196  }  }
197    
198  =head3 name  =head3 name
# Line 196  Line 211 
211                          if (defined($self->mgdata())) {                          if (defined($self->mgdata())) {
212                                  $self->{_name} = $self->mgdata()->genome_name;                                  $self->{_name} = $self->mgdata()->genome_name;
213                          }                          }
                 } elsif (defined($self->stats())) {  
                         $self->{_name} = $self->stats()->{'Organism name'}->[0];  
214                  } elsif ($source !~ /^RAST/) {                  } elsif ($source !~ /^RAST/) {
215                          $self->{_name} = $self->fig()->orgname_of_orgid($self->genome());                          $self->{_name} = $self->fig()->orgname_of_orgid($self->genome());
216                    } else {
217                            $self->{_name} = $self->figmodel()->get_genome_stats($self->genome())->{NAME}->[0];
218                  }                  }
219          }          }
220    
221          return $self->{_name};          return $self->{_name};
222  }  }
223    
 =head3 stats  
 Definition:  
         string = FIGMODELmodel->stats();  
 Description:  
         Returns model stats  
 =cut  
 sub stats {  
         my ($self) = @_;  
   
         if (!defined($self->{_stats})) {  
                 $self->{_stats} = $self->figmodel()->database()->GetDBTable("MODEL STATS")->get_row_by_key($self->id(),"Model ID");  
         }  
         return $self->{_stats};  
 }  
   
224  =head3 get_reaction_class  =head3 get_reaction_class
225  Definition:  Definition:
226          string = FIGMODELmodel->get_reaction_class(string::reaction ID);          string = FIGMODELmodel->get_reaction_class(string::reaction ID);
# Line 228  Line 228 
228          Returns reaction class          Returns reaction class
229  =cut  =cut
230  sub get_reaction_class {  sub get_reaction_class {
231          my ($self,$reaction,$nohtml) = @_;          my ($self,$reaction,$nohtml,$brief_flux) = @_;
232    
233          if (!-e $self->directory()."ReactionClassification-".$self->id().".tbl") {          if (!-e $self->directory()."ReactionClassification-".$self->id().".tbl") {
234                  if (!defined($self->{_reaction_classes})) {                  if (!defined($self->{_reaction_classes})) {
# Line 241  Line 241 
241                  my $ClassRow = $self->{_reaction_classes}->get_row_by_key($reaction,"REACTION");                  my $ClassRow = $self->{_reaction_classes}->get_row_by_key($reaction,"REACTION");
242                  if (defined($ClassRow) && defined($ClassRow->{CLASS})) {                  if (defined($ClassRow) && defined($ClassRow->{CLASS})) {
243                          my $class;                          my $class;
244                            my $min = $ClassRow->{MIN}->[0];
245                            my $max = $ClassRow->{MAX}->[0];
246                          if ($ClassRow->{CLASS}->[0] eq "Positive") {                          if ($ClassRow->{CLASS}->[0] eq "Positive") {
247                                  $class = "Essential =>";                                  $class = "Essential =>";
248                                    $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
249                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative") {
250                                  $class = "Essential <=";                                  $class = "Essential <=";
251                                    $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
252                          } elsif ($ClassRow->{CLASS}->[0] eq "Positive variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Positive variable") {
253                                  $class = "Active =>";                                  $class = "Active =>";
254                                    $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
255                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative variable") {
256                                  $class = "Active <=";                                  $class = "Active <=";
257                                    $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
258                          } elsif ($ClassRow->{CLASS}->[0] eq "Variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Variable") {
259                                  $class = "Active <=>";                                  $class = "Active <=>";
260                                    $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
261                          } elsif ($ClassRow->{CLASS}->[0] eq "Blocked") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Blocked") {
262                                  $class = "Inactive";                                  $class = "Inactive";
263                          } elsif ($ClassRow->{CLASS}->[0] eq "Dead") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Dead") {
264                                  $class = "Disconnected";                                  $class = "Disconnected";
265                          }                          }
266    
267                          if (!defined($nohtml) || $nohtml ne "1") {                          if (!defined($nohtml) || $nohtml ne "1") {
268                                  $class = "<span title=\"Flux:".$ClassRow->{MIN}->[0]." to ".$ClassRow->{MAX}->[0]."\">".$class."</span>";                                  $class = "<span title=\"Flux:".$min." to ".$max."\">".$class."</span>";
269                          }                          }
270    
271                          return $class;                          return $class;
272                  }                  }
273                  return undef;                  return undef;
# Line 279  Line 288 
288                                  $classstring .= "<br>";                                  $classstring .= "<br>";
289                          }                          }
290                          my $NewClass;                          my $NewClass;
291                            my $min = $ClassRow->{MIN}->[$i];
292                            my $max = $ClassRow->{MAX}->[$i];
293                          if ($ClassRow->{CLASS}->[$i] eq "Positive") {                          if ($ClassRow->{CLASS}->[$i] eq "Positive") {
294                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential =>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential =>";
295                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
296                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative") {
297                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential <=";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential <=";
298                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
299                          } elsif ($ClassRow->{CLASS}->[$i] eq "Positive variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Positive variable") {
300                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active =>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active =>";
301                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
302                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative variable") {
303                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=";
304                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
305                          } elsif ($ClassRow->{CLASS}->[$i] eq "Variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Variable") {
306                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=>";
307                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
308                          } elsif ($ClassRow->{CLASS}->[$i] eq "Blocked") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Blocked") {
309                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Inactive";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Inactive";
                                 if (!defined($nohtml) || $nohtml ne "1") {  
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
310                          } elsif ($ClassRow->{CLASS}->[$i] eq "Dead") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Dead") {
311                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Disconnected";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Disconnected";
                                 if (!defined($nohtml) || $nohtml ne "1") {  
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
312                                  }                                  }
313    
314                            if (!defined($nohtml) || $nohtml ne "1") {
315                                    $NewClass = "<span title=\"Flux:".$min." to ".$max."\">".$NewClass."</span>";
316                          }                          }
317                          $classstring .= $NewClass;                          $classstring .= $NewClass;
318                  }                  }
# Line 332  Line 331 
331    
332          if (!defined($self->{_biomass})) {          if (!defined($self->{_biomass})) {
333                  my $rxntbl = $self->reaction_table();                  my $rxntbl = $self->reaction_table();
334                    if (defined($rxntbl)) {
335                  for (my $i=0; $i < $rxntbl->size(); $i++) {                  for (my $i=0; $i < $rxntbl->size(); $i++) {
336                          if ($rxntbl->get_row($i)->{"LOAD"}->[0] =~ m/bio\d\d\d\d\d/) {                          if ($rxntbl->get_row($i)->{"LOAD"}->[0] =~ m/bio\d\d\d\d\d/) {
337                                  $self->{_biomass} = $rxntbl->get_row($i)->{"LOAD"}->[0];                                  $self->{_biomass} = $rxntbl->get_row($i)->{"LOAD"}->[0];
# Line 339  Line 339 
339                          }                          }
340                  }                  }
341          }          }
342            }
343    
344          return $self->get_reaction_data($self->{_biomass});          return $self->get_reaction_data($self->{_biomass});
345  }  }
# Line 377  Line 378 
378          return $Data->{LOAD}->[0];          return $Data->{LOAD}->[0];
379  }  }
380    
381    =head3 load_model_table
382    
383    Definition: FIGMODELTable = FIGMODELmodel->load_model_table(string:table name,0/1:refresh the table));
384    
385    Description: Returns the table specified by the input filename. Table will be stored in a file in the model directory.
386    
387    =cut
388    sub load_model_table {
389            my ($self,$name,$refresh) = @_;
390            if (!defined($refresh)) {
391                    $refresh = 1;
392            }
393            if ($refresh == 1) {
394                    delete $self->{"_".$name};
395            }
396            if (!defined($self->{"_".$name})) {
397                    my $tbldef = $self->figmodel()->config("$name");
398                    if (!defined($tbldef)) {
399                            return undef;
400                    }
401                    my $filename = $self->directory().$name."-".$self->id().$self->selected_version().".tbl";
402                    $self->{"_".$name} = $self->figmodel()->database()->load_table($filename,"\t","|",$tbldef->{headingline}->[0],$tbldef->{hashcolumns});
403                    if (!defined($self->{"_".$name})) {
404                            if (defined($tbldef->{prefix})) {
405                                    $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},"\t","|",join(@{$tbldef->{prefix}},"\n"));
406                            } else {
407                                    $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},"\t","|");
408                            }
409                    }
410            }
411            return $self->{"_".$name};
412    }
413    
414    =head3 create_table_prototype
415    
416    Definition:
417            FIGMODELTable::table = FIGMODELmodel->create_table_prototype(string::table);
418    Description:
419            Returns a empty FIGMODELTable with all the metadata associated with the input table name
420    
421    =cut
422    sub create_table_prototype {
423            my ($self,$TableName) = @_;
424    
425            #Checking if the table definition exists in the FIGMODELconfig file
426            if (!defined($self->figmodel()->config($TableName))) {
427                    $self->figmodel()->error_message("FIGMODELdatabase:create_table_prototype:Definition not found for ".$TableName);
428                    return undef;
429            }
430            #Checking that this is a database table
431            if (!defined($self->config($TableName)->{tabletype}) || $self->config($TableName)->{tabletype}->[0] ne "ModelTable") {
432                    $self->figmodel()->error_message("FIGMODELdatabase:create_table_prototype:".$TableName." is not a model table!");
433                    return undef;
434            }
435            if (!defined($self->config($TableName)->{delimiter})) {
436                    $self->config($TableName)->{delimiter}->[0] = ";";
437            }
438            if (!defined($self->config($TableName)->{itemdelimiter})) {
439                    $self->config($TableName)->{itemdelimiter}->[0] = "|";
440            }
441            my $prefix;
442            if (defined($self->config($TableName)->{prefix})) {
443                    $prefix = join("\n",@{$self->config($TableName)->{prefix}});
444            }
445            my $tbl = FIGMODELTable->new($self->config($TableName)->{columns},$self->directory().$self->config($TableName)->{filename_prefix}->[0]."-".$self->id().$self->selected_version().".txt",$self->config($TableName)->{hashcolumns},$self->config($TableName)->{delimiter}->[0],$self->config($TableName)->{itemdelimiter}->[0],$prefix);
446            return $tbl;
447    }
448    
449  =head3 get_reaction_number  =head3 get_reaction_number
450  Definition:  Definition:
451          int = FIGMODELmodel->get_reaction_number();          int = FIGMODELmodel->get_reaction_number();
# Line 385  Line 454 
454  =cut  =cut
455  sub get_reaction_number {  sub get_reaction_number {
456          my ($self) = @_;          my ($self) = @_;
   
457          if (!defined($self->reaction_table())) {          if (!defined($self->reaction_table())) {
458                  return 0;                  return 0;
459          }          }
   
460          return $self->reaction_table()->size();          return $self->reaction_table()->size();
461  }  }
462    
# Line 404  Line 471 
471    
472          if (!defined($self->{_reaction_data})) {          if (!defined($self->{_reaction_data})) {
473                  $self->{_reaction_data} = $self->figmodel()->database()->GetDBModel($self->id());                  $self->{_reaction_data} = $self->figmodel()->database()->GetDBModel($self->id());
474                    my $classTbl = $self->reaction_class_table();
475                    for (my $i=0; $i < $classTbl->size(); $i++) {
476                            my $row = $classTbl->get_row($i);
477                            my $rxnRow = $self->{_reaction_data}->get_row_by_key($row->{"REACTION"}->[0],"LOAD");
478                            for (my $j=0; $j < @{$row->{MEDIA}};$j++) {
479                                    my $class = "Active <=>";
480                                    if ($row->{CLASS}->[$j] eq "Positive") {
481                                            $class = "Essential =>";
482                                    } elsif ($row->{CLASS}->[$j] eq "Negative") {
483                                            $class = "Essential <=";
484                                    } elsif ($row->{CLASS}->[$j] eq "Blocked") {
485                                            $class = "Inactive";
486                                    } elsif ($row->{CLASS}->[$j] eq "Positive variable") {
487                                            $class = "Active =>";
488                                    } elsif ($row->{CLASS}->[$j] eq "Negative variable") {
489                                            $class = "Active <=";
490                                    } elsif ($row->{CLASS}->[$j] eq "Variable") {
491                                            $class = "Active <=>";
492                                    } elsif ($row->{CLASS}->[$j] eq "Dead") {
493                                            $class = "Dead";
494                                    }
495                                    push(@{$rxnRow->{PREDICTIONS}},$row->{MEDIA}->[$j].":".$class);
496                            }
497                    }
498          }          }
499    
500          return $self->{_reaction_data};          return $self->{_reaction_data};
501  }  }
502    
503    =head3 feature_table
504    Definition:
505            FIGMODELTable = FIGMODELmodel->feature_table();
506    Description:
507            Returns FIGMODELTable with the feature list for the model
508    =cut
509    sub feature_table {
510            my ($self) = @_;
511    
512            if (!defined($self->{_feature_data})) {
513                    #Getting the genome feature list
514                    my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
515                    if (!defined($FeatureTable)) {
516                            print STDERR "FIGMODELmodel:feature_table:Could not get features for genome ".$self->genome()." in database!";
517                            return undef;
518                    }
519                    #Getting the reaction table for the model
520                    my $rxnTable = $self->reaction_table();
521                    if (!defined($rxnTable)) {
522                    print STDERR "FIGMODELmodel:feature_table:Could not get reaction table for model ".$self->id()." in database!";
523                            return undef;
524                }
525                    #Cloning the feature table
526                    $self->{_feature_data} = $FeatureTable->clone_table_def();
527                    $self->{_feature_data}->add_headings(($self->id()."REACTIONS",$self->id()."PREDICTIONS"));
528                for (my $i=0; $i < $rxnTable->size(); $i++) {
529                    my $Row = $rxnTable->get_row($i);
530                    if (defined($Row) && defined($Row->{"ASSOCIATED PEG"})) {
531                            foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {
532                                    my $temp = $GeneSet;
533                                    $temp =~ s/\+/|/g;
534                                    $temp =~ s/\sAND\s/|/gi;
535                                    $temp =~ s/\sOR\s/|/gi;
536                                    $temp =~ s/[\(\)\s]//g;
537                                    my @GeneList = split(/\|/,$temp);
538                                    foreach my $Gene (@GeneList) {
539                                    my $FeatureRow = $self->{_feature_data}->get_row_by_key("fig|".$self->genome().".".$Gene,"ID");
540                                                    if (!defined($FeatureRow)) {
541                                                            $FeatureRow = $FeatureTable->get_row_by_key("fig|".$self->genome().".".$Gene,"ID");
542                                                            if (defined($FeatureRow)) {
543                                                                    $self->{_feature_data}->add_row($FeatureRow);
544                                                            }
545                                                    }
546                                                    if (defined($FeatureRow)) {
547                                                            $self->{_feature_data}->add_data($FeatureRow,$self->id()."REACTIONS",$Row->{"LOAD"}->[0],1);
548                                                    }
549                                    }
550                            }
551                    }
552                }
553                #Loading predictions
554                my @files = glob($self->directory()."EssentialGenes-".$self->id()."-*");
555                foreach my $file (@files) {
556                    if ($file =~ m/\-([^\-]+)\.tbl/) {
557                            my $media = $1;
558                            my $list = $self->figmodel()->database()->load_single_column_file($file,"");
559                            my $hash;
560                            foreach my $gene (@{$list}) {
561                                    $hash->{$gene} = 1;
562                            }
563                            for (my $i=0; $i < $self->{_feature_data}->size(); $i++) {
564                                    my $Row = $self->{_feature_data}->get_row($i);
565                                    if ($Row->{ID}->[0] =~ m/(peg\.\d+)/) {
566                                            my $gene = $1;
567                                            if (defined($hash->{$gene})) {
568                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":essential");
569                                            } else {
570                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":nonessential");
571                                            }
572                                    }
573                            }
574                    }
575                }
576            }
577            return $self->{_feature_data};
578    }
579    
580  =head3 reaction_class_table  =head3 reaction_class_table
581  Definition:  Definition:
582          FIGMODELTable = FIGMODELmodel->reaction_class_table();          FIGMODELTable = FIGMODELmodel->reaction_class_table();
# Line 489  Line 657 
657    
658  =head3 get_compound_data  =head3 get_compound_data
659  Definition:  Definition:
660          string = FIGMODELmodel->get_compound_data(string::compound ID);          {string:key=>[string]:values} = FIGMODELmodel->get_compound_data(string::compound ID);
661  Description:  Description:
662          Returns model compound data          Returns model compound data
663  =cut  =cut
# Line 500  Line 668 
668                  return undef;                  return undef;
669          }          }
670          if ($compound =~ m/^\d+$/) {          if ($compound =~ m/^\d+$/) {
671                  $self->compound_table()->get_row($compound);                  return $self->compound_table()->get_row($compound);
672          }          }
673          return $self->compound_table()->get_row_by_key($compound,"DATABASE");          return $self->compound_table()->get_row_by_key($compound,"DATABASE");
674  }  }
675    
676    =head3 get_feature_data
677    Definition:
678            {string:key=>[string]:values} = FIGMODELmodel->get_feature_data(string::feature ID);
679    Description:
680            Returns model feature data
681    =cut
682    sub get_feature_data {
683            my ($self,$feature) = @_;
684            if (!defined($self->feature_table())) {
685                    return undef;
686            }
687            if ($feature =~ m/^\d+$/) {
688                    return $self->feature_table()->get_row($feature);
689            }
690            if ($feature =~ m/(peg\.\d+)/) {
691                    $feature = $1;
692            }
693            return $self->feature_table()->get_row_by_key("fig|".$self->genome().".".$feature,"ID");
694    }
695    
696  =head3 genome  =head3 genome
697  Definition:  Definition:
698          string = FIGMODELmodel->genome();          string = FIGMODELmodel->genome();
# Line 513  Line 701 
701  =cut  =cut
702  sub genome {  sub genome {
703          my ($self) = @_;          my ($self) = @_;
704          return $self->{_data}->{genome}->[0];          return $self->{_data}->genome();
705  }  }
706    
707  =head3 source  =head3 source
# Line 524  Line 712 
712  =cut  =cut
713  sub source {  sub source {
714          my ($self) = @_;          my ($self) = @_;
715          return $self->{_data}->{source}->[0];          return $self->{_data}->source();
716  }  }
717    
718  =head3 rights  =head3 rights
# Line 535  Line 723 
723  =cut  =cut
724  sub rights {  sub rights {
725          my ($self,$username) = @_;          my ($self,$username) = @_;
   
726          if ($self->public()) {          if ($self->public()) {
727                  return 1;                  return 1;
728          }          }
# Line 543  Line 730 
730                  return 0;                  return 0;
731          }          }
732          if (!defined($self->{_userrights}->{$username})) {          if (!defined($self->{_userrights}->{$username})) {
733                  if (defined($self->{_data}->{master})) {                  $self->{_userrights}->{$self->{_data}->owner()} = 1;
734                          for (my $i=0; $i < @{$self->{_data}->{master}};$i++) {                  my @users = split(/\|/,$self->{_data}->users());
735                                  $self->{_userrights}->{$self->{_data}->{master}->[$i]} = 1;                  for (my $i=0; $i < @users;$i++) {
736                          }                          $self->{_userrights}->{$users[$i]} = 1;
                 }  
                 if (defined($self->{_data}->{users})) {  
                         for (my $i=0; $i < @{$self->{_data}->{users}};$i++) {  
                                 $self->{_userrights}->{$self->{_data}->{users}->[$i]} = 1;  
                         }  
737                  }                  }
738          }          }
739          return $self->{_userrights}->{$username};          return $self->{_userrights}->{$username};
# Line 565  Line 747 
747  =cut  =cut
748  sub public {  sub public {
749          my ($self) = @_;          my ($self) = @_;
750            if ($self->{_data}->users() eq "all") {
751          if (!defined($self->{_public})) {                  return 1;
                 $self->{_public} = 0;  
                 if (defined($self->{_data}->{users}->[0]) && $self->{_data}->{users}->[0] eq "all") {  
                         $self->{_public} = 1;  
                 }  
752          }          }
753          return $self->{_public};          return 0;
754  }  }
755    
756  =head3 directory  =head3 directory
# Line 620  Line 798 
798          return $self->directory().$self->id().$self->selected_version().".txt";          return $self->directory().$self->id().$self->selected_version().".txt";
799  }  }
800    
 =head3 set_metagenome_stats  
 Definition:  
         string = FIGMODELmodel->set_metagenome_stats();  
 Description:  
         Sets the values of many model stats for a metagenome  
 =cut  
 sub set_metagenome_stats {  
         my ($self) = @_;  
   
         $self->{_total_compounds} = 0;  
         if (defined($self->compound_table())) {  
                 $self->{_total_compounds} = $self->compound_table()->size();  
         }  
         $self->{_gene_reactions} = 0;  
         $self->{_gapfilling_reactions} = 0;  
         $self->{_model_genes} = 0;  
         $self->{_total_reactions} = 0;  
         if (defined($self->reaction_table())) {  
                 $self->{_total_reactions} = $self->reaction_table()->size();  
                 my $tbl = $self->reaction_table();  
                 my $spontaneous = 0;  
                 for (my $i=0; $i < $tbl->size(); $i++) {  
                         my $row = $tbl->get_row($i);  
                         if (!defined($row->{"ASSOCIATED PEG"}->[0]) || $row->{"ASSOCIATED PEG"}->[0] !~ m/peg/) {  
                                 if ($row->{"ASSOCIATED PEG"}->[0] =~ m/SPONTANEOUS/) {  
                                         $spontaneous++;  
                                 } else {  
                                         $self->{_gapfilling_reactions}++;  
                                 }  
                         } else {  
                                 for (my $j=0; $j < @{$row->{"CONFIDENCE"}}; $j++) {  
                                         my @ecores = split(/;/,$row->{"CONFIDENCE"}->[$j]);  
                                         $self->{_model_genes} += @ecores;  
                                 }  
                         }  
                 }  
                 $self->{_gene_reactions} = $tbl->size() - $spontaneous - $self->{_gapfilling_reactions};  
         }  
 }  
   
801  =head3 version  =head3 version
802  Definition:  Definition:
803          string = FIGMODELmodel->version();          string = FIGMODELmodel->version();
# Line 671  Line 809 
809    
810          if (!defined($self->{_version})) {          if (!defined($self->{_version})) {
811                  if (!defined($self->{_selectedversion})) {                  if (!defined($self->{_selectedversion})) {
812                          if (defined($self->stats())) {                          $self->{_version} = "V".$self->{_data}->version().".".$self->{_data}->autocompleteVersion();
                                 $self->{_version} = "V".$self->stats()->{"Version"}->[0].".".$self->stats()->{"Gap fill version"}->[0];  
                         }  
813                  } else {                  } else {
814                          $self->{_version} = $self->{_selectedversion};                          $self->{_version} = $self->{_selectedversion};
815                  }                  }
# Line 704  Line 840 
840  =cut  =cut
841  sub modification_time {  sub modification_time {
842          my ($self) = @_;          my ($self) = @_;
843          if (!defined($self->{_modification_time})) {          return $self->{_data}->modificationDate();
                 my $stats = $self->stats();  
                 if (defined($stats)) {  
                         $self->{_modification_time} = 0;  
                         if (defined($stats->{"Build date"}->[0]) && $self->{_modification_time} < $stats->{"Build date"}->[0]) {  
                                 $self->{_modification_time} = $stats->{"Build date"}->[0];  
                         } elsif (defined($stats->{"Gap fill date"}->[0]) && $self->{_modification_time} < $stats->{"Gap fill date"}->[0]) {  
                                 $self->{_modification_time} = $stats->{"Gap fill date"}->[0];  
                         }  
                 } else {  
                         $self->{_modification_time} = 0;  
                 }  
         }  
         return $self->{_modification_time};  
844  }  }
845    
846  =head3 gene_reactions  =head3 gene_reactions
# Line 728  Line 851 
851  =cut  =cut
852  sub gene_reactions {  sub gene_reactions {
853          my ($self) = @_;          my ($self) = @_;
854            return ($self->{_data}->reactions() - $self->{_data}->autoCompleteReactions() - $self->{_data}->spontaneousReactions() - $self->{_data}->gapFillReactions());
         if (!defined($self->{_gene_reactions})) {  
                 if ($self->source() =~ /^MGRAST/) {  
                         $self->set_metagenome_stats();  
                 } elsif (defined($self->stats())) {  
                         $self->{_gene_reactions} = $self->total_reactions() - $self->gapfilling_reactions() - $self->stats()->{'Spontaneous'}->[0] - $self->stats()->{'Growmatch reactions'}->[0] - $self->stats()->{'Biolog gap filling reactions'}->[0];  
                 }  
         }  
         return $self->{_gene_reactions};  
855  }  }
856    
857  =head3 total_compounds  =head3 total_compounds
# Line 747  Line 862 
862  =cut  =cut
863  sub total_compounds {  sub total_compounds {
864          my ($self) = @_;          my ($self) = @_;
865            return $self->{_data}->compounds();
         if (!defined($self->{_total_compounds})) {  
                 if ($self->source() =~ /^MGRAST/) {  
                         $self->set_metagenome_stats();  
                 } elsif (defined($self->stats())) {  
                         $self->{_total_compounds} = $self->stats()->{'Metabolites'}->[0];  
                 }  
         }  
         return $self->{_total_compounds};  
866  }  }
867    
868  =head3 gapfilling_reactions  =head3 gapfilling_reactions
# Line 766  Line 873 
873  =cut  =cut
874  sub gapfilling_reactions {  sub gapfilling_reactions {
875          my ($self) = @_;          my ($self) = @_;
876            return ($self->{_data}->autoCompleteReactions()+$self->{_data}->gapFillReactions());
         if (!defined($self->{_gapfilling_reactions})) {  
                 if ($self->source() =~ /^MGRAST/) {  
                         $self->set_metagenome_stats();  
                 } elsif (defined($self->stats())) {  
                         $self->{_gapfilling_reactions} = $self->stats()->{'Gap filling reactions'}->[0];  
                 }  
         }  
         return $self->{_gapfilling_reactions};  
877  }  }
878    
879  =head3 total_reactions  =head3 total_reactions
# Line 785  Line 884 
884  =cut  =cut
885  sub total_reactions {  sub total_reactions {
886          my ($self) = @_;          my ($self) = @_;
887            return $self->{_data}->reactions();
         if (!defined($self->{_total_reactions})) {  
                 if ($self->source() =~ /^MGRAST/) {  
                         $self->set_metagenome_stats();  
                 } elsif (defined($self->stats())) {  
                         $self->{_total_reactions} = $self->stats()->{'Number of reactions'}->[0];  
                 }  
         }  
         return $self->{_total_reactions};  
888  }  }
889    
890  =head3 model_genes  =head3 model_genes
# Line 804  Line 895 
895  =cut  =cut
896  sub model_genes {  sub model_genes {
897          my ($self) = @_;          my ($self) = @_;
898            return $self->{_data}->associatedGenes();
         if (!defined($self->{_model_genes})) {  
                 if ($self->source() =~ /^MGRAST/) {  
                         $self->set_metagenome_stats();  
                 } elsif (defined($self->stats())) {  
                         $self->{_model_genes} = $self->stats()->{'Genes with reactions'}->[0];  
                 }  
         }  
         return $self->{_model_genes};  
899  }  }
900    
901  =head3 class  =head3 class
# Line 823  Line 906 
906  =cut  =cut
907  sub class {  sub class {
908          my ($self) = @_;          my ($self) = @_;
909            return $self->{_data}->cellwalltype();
         if (!defined($self->{_class})) {  
                 if ($self->source() =~ /^MGRAST/) {  
                         $self->{_class} = "Other";  
                 } elsif (defined($self->stats())) {  
                         $self->{_class} = $self->stats()->{Class}->[0];  
                 }  
         }  
         return $self->{_class};  
910  }  }
911    
912  =head3 taxonomy  =head3 taxonomy
# Line 899  Line 974 
974                          if (defined($self->mgdata())) {                          if (defined($self->mgdata())) {
975                                  $self->{_genome_genes} = $self->mgdata()->genome_contig_count;                                  $self->{_genome_genes} = $self->mgdata()->genome_contig_count;
976                          }                          }
977                  } elsif (defined($self->stats())) {                  } else {
978                          $self->{_genome_genes} = $self->stats()->{'Total genes'}->[0];                          $self->{_genome_genes} = $self->figmodel()->get_genome_stats($self->genome())->{"TOTAL GENES"}->[0];
979                  }                  }
980          }          }
981    
# Line 941  Line 1016 
1016          return $self->figmodel()->success();          return $self->figmodel()->success();
1017  }  }
1018    
 =head3 save_obsolete_stats  
 Definition:  
         FIGMODELmodel->save_obsolete_stats();  
 Description:  
 =cut  
 sub save_obsolete_stats {  
         my ($self) = @_;  
   
         #checking if stats exists  
         my $stats = $self->stats();  
         if (defined($stats)) {  
                 $stats->{"Model ID"}->[0] = $self->id()."V".$stats->{"Version"}->[0].".".$stats->{"Gap fill version"}->[0];  
                 $self->figmodel()->database()->update_row("OBSOLETE MODEL STATS",$stats,"Model ID");  
                 $stats->{"Model ID"}->[0] = $self->id();  
         }  
 }  
   
1019  =head3 update_stats_for_gap_filling  =head3 update_stats_for_gap_filling
1020  Definition:  Definition:
1021          {string => [string]} = FIGMODELmodel->update_stats_for_gap_filling(int::gapfill time);          {string => [string]} = FIGMODELmodel->update_stats_for_gap_filling(int::gapfill time);
# Line 965  Line 1023 
1023  =cut  =cut
1024  sub update_stats_for_gap_filling {  sub update_stats_for_gap_filling {
1025          my ($self,$gapfilltime) = @_;          my ($self,$gapfilltime) = @_;
1026            $self->{_data}->autoCompleteTime($gapfilltime);
1027          #preserving the stats for the now obselete model          $self->{_data}->autocompleteDate(time());
1028          $self->save_obsolete_stats();          $self->{_data}->modificationDate(time());
1029          my $stats = $self->update_model_stats(0);          my $version = $self->{_data}->autocompleteVersion();
1030          $stats->{"Gap filling time"}->[0] = $gapfilltime;          $self->{_data}->autocompleteVersion($version+1);
         $stats->{"Gap fill date"}->[0] = time();  
         if (!defined($stats->{"Gap fill version"}->[0])) {  
                 $stats->{"Gap fill version"}->[0] = 0;  
         }  
         $stats->{"Gap fill version"}->[0]++;  
   
         #Updating the stats stored in the table  
         $self->figmodel()->database()->update_row("MODEL STATS",$stats,"Model ID");  
         return $stats;  
1031  }  }
1032    
1033  =head3 update_stats_for_build  =head3 update_stats_for_build
# Line 988  Line 1037 
1037  =cut  =cut
1038  sub update_stats_for_build {  sub update_stats_for_build {
1039          my ($self) = @_;          my ($self) = @_;
1040            $self->{_data}->builtDate(time());
1041          #preserving the stats for the now obselete model          $self->{_data}->modificationDate(time());
1042          $self->save_obsolete_stats();          my $version = $self->{_data}->version();
1043          my $stats = $self->update_model_stats(0);          $self->{_data}->version($version+1);
         $stats->{"Build date"}->[0] = time();  
         if (!defined($stats->{"Version"}->[0])) {  
                 $stats->{"Version"}->[0] = 0;  
         }  
         $stats->{"Version"}->[0]++;  
   
         #Updating the stats stored in the table  
         $self->figmodel()->database()->update_row("MODEL STATS",$stats,"Model ID");  
         return $stats;  
1044  }  }
1045    
1046  =head3 update_model_stats  =head3 update_model_stats
# Line 1019  Line 1059 
1059          }          }
1060          my $cpdtbl = $self->compound_table();          my $cpdtbl = $self->compound_table();
1061    
1062          #Creating empty status row          #Calculating all necessary stats
         my $CurrentStats = {"Genes with reactions" => [0],  
                                                  "Metabolites" => [$cpdtbl->size()],  
                                                  "Growmatch reactions" => [0],  
                                                  "Spontaneous" => [0],  
                                                  "Biolog gap filling reactions" => [0],  
                                                  "Number of reactions" => [$rxntbl->size()],  
                                                  "Transport reaction"=>[0],  
                                                  "Gap filling reactions" => [0],  
                                                  "Model ID" => [$self->id()],  
                                                  "Subsystem genes with reactions" => [0],  
                                                  "Nonsubsystem genes with reactions" => [0],  
                                                  Version => [0],  
                                                  "Gap fill version" => [0],  
                                                  Source => [$self->source()],  
                                                  "Genes with one reaction" => [0],  
                                                  "Genome ID" => [$self->genome()]};  
   
         my $genomestats = $self->figmodel()->get_genome_stats($self->genome());  
         if (defined($genomestats)) {  
                 $CurrentStats->{SOURCE}->[0] = $genomestats->{SOURCE}->[0];  
                 $CurrentStats->{"Organism name"}->[0] = $genomestats->{NAME}->[0];  
                 $CurrentStats->{"Total genes"}->[0] = $genomestats->{"TOTAL GENES"}->[0];  
                 $CurrentStats->{"Gram positive genes"}->[0] = $genomestats->{"GRAM POSITIVE GENES"}->[0];  
                 $CurrentStats->{"Gram negative genes"}->[0] = $genomestats->{"GRAM NEGATIVE GENES"}->[0];  
                 $CurrentStats->{"Class"}->[0] = $genomestats->{CLASS}->[0];  
                 $CurrentStats->{"Genes with functions"}->[0] = $genomestats->{"GENES WITH FUNCTIONS"}->[0];  
                 $CurrentStats->{"Subsystem genes"}->[0] = $genomestats->{"SUBSYSTEM GENES"}->[0];  
                 $CurrentStats->{"Nonsubsystem genes"}->[0] = $genomestats->{"NON SUBSYSTEM GENES"}->[0];  
                 if (defined($genomestats->{TAXONOMY})) {  
                         $CurrentStats->{"Taxonomy 0"}->[0] = $genomestats->{TAXONOMY}->[0];  
                         $CurrentStats->{"Taxonomy 1"}->[0] = $genomestats->{TAXONOMY}->[1];  
                         $CurrentStats->{"Taxonomy 2"}->[0] = $genomestats->{TAXONOMY}->[2];  
                         $CurrentStats->{"Taxonomy 3"}->[0] = $genomestats->{TAXONOMY}->[3];  
                         $CurrentStats->{"Taxonomy 4"}->[0] = $genomestats->{TAXONOMY}->[4];  
                         $CurrentStats->{"Taxonomy 5"}->[0] = $genomestats->{TAXONOMY}->[5];  
                 }  
         }  
   
         #Transfering build, version, and gap fill data from existing stats  
         if (defined($self->stats())) {  
                 $CurrentStats->{Version}->[0] = $self->stats()->{Version}->[0];  
                 $CurrentStats->{"Gap fill version"}->[0] = $self->stats()->{"Gap fill version"}->[0];  
                 $CurrentStats->{"Gap filling time"}->[0] = $self->stats()->{"Gap filling time"}->[0];  
                 $CurrentStats->{"Gap fill date"}->[0] = $self->stats()->{"Gap fill date"}->[0];  
                 $CurrentStats->{"Build date"}->[0] = $self->stats()->{"Build date"}->[0];  
         }  
   
1063          my %GeneHash;          my %GeneHash;
1064          my %NonpegHash;          my %NonpegHash;
1065          my %CompoundHash;          my %CompoundHash;
1066            my $spontaneousReactions = 0;
1067            my $gapFillReactions = 0;
1068            my $biologReactions = 0;
1069            my $transporters = 0;
1070            my $autoCompleteReactions = 0;
1071            my $associatedSubsystemGenes = 0;
1072          for (my $i=0; $i < $rxntbl->size(); $i++) {          for (my $i=0; $i < $rxntbl->size(); $i++) {
1073                  my $Row = $rxntbl->get_row($i);                  my $Row = $rxntbl->get_row($i);
1074                  if (defined($Row) && defined($Row->{"ASSOCIATED PEG"})) {                  if (defined($Row) && defined($Row->{"ASSOCIATED PEG"})) {
# Line 1077  Line 1076 
1076                          if (defined($ReactionRow->{"EQUATION"}->[0])) {                          if (defined($ReactionRow->{"EQUATION"}->[0])) {
1077                                  #Checking for extracellular metabolites which indicate that this is a transporter                                  #Checking for extracellular metabolites which indicate that this is a transporter
1078                                  if ($ReactionRow->{"EQUATION"}->[0] =~ m/\[e\]/) {                                  if ($ReactionRow->{"EQUATION"}->[0] =~ m/\[e\]/) {
1079                                          $CurrentStats->{"Transport reaction"}->[0]++;                                          $transporters++;
1080                                  }                                  }
1081                          }                          }
1082                          #Identifying spontaneous/biolog/gapfilling/gene associated reactions                          #Identifying spontaneous/biolog/gapfilling/gene associated reactions
1083                          if ($Row->{"ASSOCIATED PEG"}->[0] =~ m/BIOLOG/i) {                          if ($Row->{"ASSOCIATED PEG"}->[0] =~ m/BIOLOG/i) {
1084                                  $CurrentStats->{"Biolog gap filling reactions"}->[0]++;                                  $biologReactions++;
1085                            } elsif ($Row->{"ASSOCIATED PEG"}->[0] =~ m/GROW/i) {
1086                                    $gapFillReactions++;
1087                          } elsif ($Row->{"ASSOCIATED PEG"}->[0] =~ m/SPONTANEOUS/i) {                          } elsif ($Row->{"ASSOCIATED PEG"}->[0] =~ m/SPONTANEOUS/i) {
1088                                  $CurrentStats->{"Spontaneous"}->[0]++;                                  $spontaneousReactions++;
1089                          } elsif ($Row->{"ASSOCIATED PEG"}->[0] =~ m/GAP/ || $Row->{"ASSOCIATED PEG"}->[0] =~ m/UNIVERSAL/i || $Row->{"ASSOCIATED PEG"}->[0] =~ m/UNKNOWN/i) {                          } elsif ($Row->{"ASSOCIATED PEG"}->[0] =~ m/GAP/ || $Row->{"ASSOCIATED PEG"}->[0] =~ m/UNIVERSAL/i || $Row->{"ASSOCIATED PEG"}->[0] =~ m/UNKNOWN/i) {
1090                                  $CurrentStats->{"Gap filling reactions"}->[0]++;                                  $autoCompleteReactions++;
1091                          } else {                          } else {
1092                                  foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {                                  foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {
1093                                          $_ = $GeneSet;                                          $_ = $GeneSet;
# Line 1104  Line 1105 
1105          }          }
1106          my @genes = keys(%GeneHash);          my @genes = keys(%GeneHash);
1107          my @othergenes = keys(%NonpegHash);          my @othergenes = keys(%NonpegHash);
         $CurrentStats->{"Genes with reactions"}->[0] = @genes + @othergenes;  
1108    
1109          #Updating the stats stored in the table          #Setting the reaction count
1110          $self->figmodel()->database()->update_row("MODEL STATS",$CurrentStats,"Model ID");          $self->{_data}->reactions($rxntbl->size());
1111          $self->{_stats} = $CurrentStats;          #Setting the metabolite count
1112          return $CurrentStats;          $self->{_data}->compounds($rxntbl->size());
1113            #Setting the gene count
1114            my $geneCount = @genes + @othergenes;
1115            $self->{_data}->associatedGenes($geneCount);
1116            #Setting remaining stats
1117            $self->{_data}->spontaneousReactions($spontaneousReactions);
1118            $self->{_data}->gapFillReactions($gapFillReactions);
1119            $self->{_data}->biologReactions($biologReactions);
1120            $self->{_data}->transporters($transporters);
1121            $self->{_data}->autoCompleteReactions($autoCompleteReactions);
1122            $self->{_data}->associatedSubsystemGenes($associatedSubsystemGenes);
1123            #Setting the model class
1124            my $class = "";
1125            for (my $i=0; $i < @{$self->figmodel()->config("class list")}; $i++) {
1126                    if (defined($self->figmodel()->config($self->figmodel()->config("class list")->[$i]))) {
1127                            if (defined($self->figmodel()->config($self->figmodel()->config("class list")->[$i])->{$self->id()})) {
1128                                    $class = $self->figmodel()->config("class list")->[$i];
1129                                    last;
1130                            }
1131                            if ($class eq "" && defined($self->figmodel()->config($self->figmodel()->config("class list")->[$i])->{$self->genome()})) {
1132                                    $class = $self->figmodel()->config("class list")->[$i];
1133                            }
1134                    }
1135            }
1136            if ($class eq "") {
1137                    $class = $self->figmodel()->get_genome_stats($self->genome())->{CLASS}->[0];
1138            }
1139            if ($class eq "") {
1140                    $class = "unknown";
1141            }
1142            $self->{_data}->cellwalltype($class);
1143  }  }
1144    
1145  =head3 GapFillModel  =head3 GapFillModel
# Line 1160  Line 1190 
1190                          }                          }
1191                  }                  }
1192                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1193                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$UniqueFilename."TestMedia",["GapFilling"],{"Default max drain flux" => 0},"GapFill".$self->id().".log",undef));                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$UniqueFilename."TestMedia",["GapFilling"],{"Default max drain flux" => 0,"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0]},"GapFill".$self->id().".log",undef));
1194                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1195          } else {          } else {
1196                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),undef,["GapFilling"],undef,"GapFill".$self->id().".log",undef));                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),undef,["GapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0]},"GapFill".$self->id().".log",undef));
1197          }          }
1198    
1199          #Parse the solutions file for the model and get the reaction list from it          #Parse the solutions file for the model and get the reaction list from it
# Line 1210  Line 1240 
1240          }          }
1241          #Updating model stats with gap filling results          #Updating model stats with gap filling results
1242          my $ElapsedTime = time() - $StartTime;          my $ElapsedTime = time() - $StartTime;
1243          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
1244          #Determining why each gap filling reaction was added          #Determining why each gap filling reaction was added
1245          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);
1246          if (!defined($donotclear) || $donotclear != 1) {          if (!defined($donotclear) || $donotclear != 1) {
# Line 1230  Line 1260 
1260          return $self->success();          return $self->success();
1261  }  }
1262    
1263  =head3 datagapfill  =head3 GapGenModel
1264  Definition:  Definition:
1265          success()/fail() = FIGMODELmodel->datagapfill();          FIGMODELmodel->GapGenModel();
1266  Description:  Description:
1267          Run gapfilling on the input run specifications          Runs the gap generation algorithm to correct a single false positive prediction. Results are loaded into a table.
1268  =cut  =cut
1269  sub datagapfill {  
1270          my ($self,$GapFillingRunSpecs,$TansferFileSuffix) = @_;  sub GapGenModel {
1271          my $UniqueFilename = $self->figmodel()->filename();          my ($self,$Media,$KOList,$NoKOList,$Experiment,$SolutionLimit) = @_;
1272          if (defined($GapFillingRunSpecs) && @{$GapFillingRunSpecs} > 0) {  
1273                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id().$self->selected_version(),"NoBounds",["DataGapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0],"Gap filling runs" => join(";",@{$GapFillingRunSpecs})},"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,undef));          #Enforcing nonoptional arguments
1274                  #Checking that the solution exists          if (!defined($Media)) {
                 if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt") {  
                         $self->figmodel()->error_message("FIGMODEL:GapFillingAlgorithm: Could not find MFA output file!");  
                         $self->figmodel()->database()->print_array_to_file($self->directory().$self->id().$self->selected_version()."-GFS.txt",["Experiment;Solution index;Solution cost;Solution reactions"]);  
1275                          return undef;                          return undef;
1276                  }                  }
1277                  my $GapFillResultTable = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt",";","",0,undef);          if (!defined($KOList)) {
1278                  if (defined($TansferFileSuffix)) {                  $KOList->[0] = "none";
                         system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt ".$self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt");  
1279                  }                  }
1280                  #If the system is not configured to preserve all logfiles, then the mfatoolkit output folder is deleted          if (!defined($NoKOList)) {
1281                  $self->figmodel()->clearing_output($UniqueFilename,"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log");                  $NoKOList->[0] = "none";
                 return $GapFillResultTable;  
1282          }          }
1283          if (defined($TansferFileSuffix)) {          if (!defined($Experiment)) {
1284                  $self->figmodel()->database()->print_array_to_file($self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt",["Experiment;Solution index;Solution cost;Solution reactions"]);                  $Experiment= "ReactionKO";
1285          }          }
1286          return undef;          if (!defined($SolutionLimit)) {
1287                    $SolutionLimit = "10";
1288  }  }
1289    
1290  =head3 datagapgen          #Translating the KO lists into arrays
1291  Definition:          if (ref($KOList) ne "ARRAY") {
1292          $model->datagapgen($NumberOfProcessors,$ProcessorIndex,$Filename);                  my $temp = $KOList;
1293  =cut                  $KOList = ();
1294                    push(@{$KOList},split(/[,;]/,$temp));
1295            }
1296            my $noKOHash;
1297            if (defined($NoKOList) && ref($NoKOList) ne "ARRAY") {
1298                    my $temp = $NoKOList;
1299                    $NoKOList = ();
1300                    push(@{$NoKOList},split(/[,;]/,$temp));
1301                    foreach my $rxn (@{$NoKOList}) {
1302                            $noKOHash->{$rxn} = 1;
1303                    }
1304            }
1305    
1306  sub datagapgen {          #Checking if solutions exist for the input parameters
1307          my ($self,$Media,$KOList,$NoKOList,$suffix) = @_;          $self->aquireModelLock();
1308          #Setting default values for inputs          my $tbl = $self->load_model_table("GapGenSolutions");
1309          if (!defined($NoKOList)) {          my $solutionRow = $tbl->get_table_by_key($Experiment,"Experiment")->get_table_by_key($Media,"Media")->get_row_by_key(join(",",@{$KOList}),"KOlist");
1310                  $NoKOList = "none";          my $solutions;
1311            if (defined($solutionRow)) {
1312                    #Checking if any solutions conform to the no KO list
1313                    foreach my $solution (@{$solutionRow->{Solutions}}) {
1314                            my @reactions = split(/,/,$solution);
1315                            my $include = 1;
1316                            foreach my $rxn (@reactions) {
1317                                    if ($rxn =~ m/(rxn\d\d\d\d\d)/) {
1318                                            if (defined($noKOHash->{$1})) {
1319                                                    $include = 0;
1320                                            }
1321                                    }
1322                            }
1323                            if ($include == 1) {
1324                                    push(@{$solutions},$solution);
1325          }          }
         if (!defined($KOList)) {  
                 $KOList = "none";  
1326          }          }
1327            } else {
1328                    $solutionRow = {Media => [$Media],Experiment => [$Experiment],KOlist => [join(",",@{$KOList})]};
1329                    $tbl->add_row($solutionRow);
1330                    $self->figmodel()->database()->save_table($tbl);
1331            }
1332            $self->releaseModelLock();
1333    
1334            #Returning solution list of solutions were found
1335            if (defined($solutions) && @{$solutions} > 0) {
1336                    return $solutions;
1337            }
1338    
1339          #Getting unique filename          #Getting unique filename
1340          my $Filename = $self->figmodel()->filename();          my $Filename = $self->figmodel()->filename();
1341          if (!defined($suffix)) {  
                 $suffix = "-".$Media."-".$KOList."-S";  
         }  
         $KOList =~ s/,/;/g;  
         $NoKOList =~ s/,/;/g;  
1342          #Running the gap generation          #Running the gap generation
1343          system($self->figmodel()->GenerateMFAToolkitCommandLineCall($Filename,$self->id().$self->selected_version(),$Media,["GapGeneration"],{"Reactions that should always be active" => $NoKOList,"Reactions to knockout" => $KOList,"Reactions that are always blocked" => "none"},"Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log",undef,undef));          system($self->figmodel()->GenerateMFAToolkitCommandLineCall($Filename,$self->id().$self->selected_version(),$Media,["GapGeneration"],{"Recursive MILP solution limit" => $SolutionLimit ,"Reactions that should always be active" => join(";",@{$NoKOList}),"Reactions to knockout" => join(";",@{$KOList}),"Reactions that are always blocked" => "none"},"Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log",undef,undef));
1344          my $ProblemReport = $self->figmodel()->LoadProblemReport($Filename);          my $ProblemReport = $self->figmodel()->LoadProblemReport($Filename);
1345          if (!defined($ProblemReport)) {          if (!defined($ProblemReport)) {
1346                  $self->figmodel()->error_message("FIGMODEL:GapGenerationAlgorithm;No problem report;".$Filename.";".$self->id().$self->selected_version().";".$Media.";".$KOList.";".$NoKOList);                  $self->figmodel()->error_message("FIGMODEL:GapGenerationAlgorithm;No problem report;".$Filename.";".$self->id().$self->selected_version().";".$Media.";".$KOList.";".$NoKOList);
1347                  return undef;                  return undef;
1348          }          }
1349    
1350          #Clearing the output folder and log file          #Clearing the output folder and log file
1351          $self->figmodel()->clearing_output($Filename,$self->directory()."Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log");          $self->figmodel()->clearing_output($Filename,"Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log");
1352          #Scheduling the testing of this gap filling solution  
1353          my $Tbl = FIGMODELTable->new(["Experiment","Solution index","Solution cost","Solution reactions"],$self->directory().$self->id().$self->selected_version()."-GG".$suffix.".txt",undef,";","|",undef);          #Saving the solution
1354            $self->aquireModelLock();
1355            $tbl = $self->load_model_table("GapGenSolutions");
1356            $solutionRow = $tbl->get_table_by_key($Experiment,"Experiment")->get_table_by_key($Media,"Media")->get_row_by_key(join(",",@{$KOList}),"KOlist");
1357          for (my $j=0; $j < $ProblemReport->size(); $j++) {          for (my $j=0; $j < $ProblemReport->size(); $j++) {
1358                  if ($ProblemReport->get_row($j)->{"Notes"}->[0] =~ m/^Recursive\sMILP\s([^)]+)/) {                  if ($ProblemReport->get_row($j)->{"Notes"}->[0] =~ m/^Recursive\sMILP\s([^)]+)/) {
1359                          my @SolutionList = split(/\|/,$1);                          my @SolutionList = split(/\|/,$1);
1360                          for (my $k=0; $k < @SolutionList; $k++) {                          for (my $k=0; $k < @SolutionList; $k++) {
1361                                  if ($SolutionList[$k] =~ m/(\d+):(.+)/) {                                  if ($SolutionList[$k] =~ m/(\d+):(.+)/) {
1362                                          $Tbl->add_row({"Experiment"=>[$Media],"Solution index"=>[$k],"Solution cost"=>[$1],"Solution reactions"=>[$2]});                                          push(@{$solutionRow->{Solutions}},$2);
1363                                            push(@{$solutions},$2);
1364                                  }                                  }
1365                          }                          }
1366                  }                  }
1367          }          }
1368          return $Tbl;          $self->figmodel()->database()->save_table($tbl);
1369            $self->releaseModelLock();
1370    
1371            return $solutions;
1372    }
1373    
1374    =head3 datagapfill
1375    Definition:
1376            success()/fail() = FIGMODELmodel->datagapfill();
1377    Description:
1378            Run gapfilling on the input run specifications
1379    =cut
1380    sub datagapfill {
1381            my ($self,$GapFillingRunSpecs,$TansferFileSuffix) = @_;
1382            my $UniqueFilename = $self->figmodel()->filename();
1383            if (defined($GapFillingRunSpecs) && @{$GapFillingRunSpecs} > 0) {
1384                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id().$self->selected_version(),"NoBounds",["DataGapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0],"Gap filling runs" => join(";",@{$GapFillingRunSpecs})},"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,undef));
1385                    #Checking that the solution exists
1386                    if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt") {
1387                            $self->figmodel()->error_message("FIGMODEL:GapFillingAlgorithm: Could not find MFA output file!");
1388                            $self->figmodel()->database()->print_array_to_file($self->directory().$self->id().$self->selected_version()."-GFS.txt",["Experiment;Solution index;Solution cost;Solution reactions"]);
1389                            return undef;
1390                    }
1391                    my $GapFillResultTable = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt",";","",0,undef);
1392                    if (defined($TansferFileSuffix)) {
1393                            system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt ".$self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt");
1394                    }
1395                    #If the system is not configured to preserve all logfiles, then the mfatoolkit output folder is deleted
1396                    $self->figmodel()->clearing_output($UniqueFilename,"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log");
1397                    return $GapFillResultTable;
1398            }
1399            if (defined($TansferFileSuffix)) {
1400                    $self->figmodel()->database()->print_array_to_file($self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt",["Experiment;Solution index;Solution cost;Solution reactions"]);
1401            }
1402            return undef;
1403  }  }
1404    
1405  =head3 TestSolutions  =head3 TestSolutions
# Line 1690  Line 1786 
1786          }          }
1787    
1788          #Checking if a biomass reaction already exists          #Checking if a biomass reaction already exists
1789          my $BiomassReactionRow = $self->figmodel()->database()->get_row_by_key("BIOMASS TABLE",$self->id(),"MODELS");          my $BiomassReactionRow = $self->BuildSpecificBiomassReaction();
         if (!defined($BiomassReactionRow)) {  
                 $BiomassReactionRow = $self->BuildSpecificBiomassReaction();  
1790                  if (!defined($BiomassReactionRow)) {                  if (!defined($BiomassReactionRow)) {
1791                          $self->set_status(-2,"Preliminary reconstruction failed: could not generate biomass reaction");                          $self->set_status(-2,"Preliminary reconstruction failed: could not generate biomass reaction");
1792                          $self->figmodel()->error_message("FIGMODEL:CreateModelReactionList: Could not generate biomass function for ".$self->id()."!");                          $self->figmodel()->error_message("FIGMODEL:CreateModelReactionList: Could not generate biomass function for ".$self->id()."!");
1793                          return $self->fail();                          return $self->fail();
1794                  }                  }
         }  
1795          my $ReactionList = $BiomassReactionRow->{"ESSENTIAL REACTIONS"};          my $ReactionList = $BiomassReactionRow->{"ESSENTIAL REACTIONS"};
1796          push(@{$ReactionList},$BiomassReactionRow->{DATABASE}->[0]);          push(@{$ReactionList},$BiomassReactionRow->{DATABASE}->[0]);
1797    
# Line 1791  Line 1884 
1884          $self->figmodel()->database()->save_table($NewModelTable);          $self->figmodel()->database()->save_table($NewModelTable);
1885          $self->{_reaction_data} = $NewModelTable;          $self->{_reaction_data} = $NewModelTable;
1886          #Clearing the previous model from the cache          #Clearing the previous model from the cache
1887          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
1888          #Updating the model stats table          #Updating the model stats table
1889          $self->update_stats_for_build();          $self->update_stats_for_build();
1890          $self->PrintSBMLFile();          $self->PrintSBMLFile();
# Line 1912  Line 2005 
2005          }          }
2006    
2007          #Clearing the previous model from the cache          #Clearing the previous model from the cache
2008          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
2009          $ModelTable->save();          $ModelTable->save();
2010    
2011          return $self->success();          return $self->success();
# Line 1928  Line 2021 
2021  sub ArchiveModel {  sub ArchiveModel {
2022          my ($self) = @_;          my ($self) = @_;
2023    
         #Making sure the model exists  
         if (!defined($self->stats())) {  
                 $self->figmodel()->error_message("FIGMODEL:ArchiveModel: Could not find specified ".$self->id()." in database!");  
                 return $self->fail();  
         }  
   
2024          #Checking that the model file exists          #Checking that the model file exists
2025          if (!(-e $self->filename())) {          if (!(-e $self->filename())) {
2026                  $self->figmodel()->error_message("FIGMODEL:ArchiveModel: Model file ".$self->filename()." not found!");                  $self->figmodel()->error_message("FIGMODEL:ArchiveModel: Model file ".$self->filename()." not found!");
# Line 2120  Line 2207 
2207          }          }
2208    
2209          #Writing output to file          #Writing output to file
2210          $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join(",",@Array)]);          $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join("|",@Array)]);
2211  }  }
2212    
2213  =head3 find_minimal_pathways  =head3 find_minimal_pathways
# Line 2238  Line 2325 
2325          }          }
2326    
2327          #Writing output to file          #Writing output to file
2328          $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join(",",@Array)]);          $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join("|",@Array)]);
2329  }  }
2330    
2331  sub combine_minimal_pathways {  sub combine_minimal_pathways {
# Line 3338  Line 3425 
3425          my $OrganismID = $self->genome();          my $OrganismID = $self->genome();
3426          #Checking for a biomass override          #Checking for a biomass override
3427          if (defined($self->config("biomass reaction override")->{$OrganismID})) {          if (defined($self->config("biomass reaction override")->{$OrganismID})) {
3428                  $biomassrxn = $self->config("biomass reaction override")->{$OrganismID};                  my $biomassID = $self->config("biomass reaction override")->{$OrganismID};
3429                  print "Overriding biomass template and selecting ".$biomassrxn." for ".$OrganismID.".\n";                  my $tbl = $self->database()->get_table("BIOMASS",1);
3430                    $biomassrxn = $tbl->get_row_by_key($biomassID,"DATABASE");
3431                    print "Overriding biomass template and selecting ".$biomassID." for ".$OrganismID.".\n";
3432          } else {#Creating biomass reaction from the template          } else {#Creating biomass reaction from the template
3433                  #Getting the genome stats                  #Getting the genome stats
3434                  my $genomestats = $self->figmodel()->get_genome_stats($self->genome());                  my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
# Line 3630  Line 3719 
3719    
3720                  #Adding the biomass equation to the biomass table                  #Adding the biomass equation to the biomass table
3721                  my $NewRow = $self->figmodel()->add_biomass_reaction($Equation,$self->id(),"Template:".$self->genome());                  my $NewRow = $self->figmodel()->add_biomass_reaction($Equation,$self->id(),"Template:".$self->genome());
3722                  $biomassrxn = $NewRow->{DATABASE}->[0];                  $biomassrxn = $NewRow;
                 print $biomassrxn."\n";  
3723          }          }
3724          print $biomassrxn."\n";          return $biomassrxn;
         my $BiomassRow = $self->figmodel()->add_model_to_biomass_reaction($biomassrxn,$self->id());  
         return $BiomassRow;  
3725  }  }
3726    
3727  =head3 PrintSBMLFile  =head3 PrintSBMLFile
# Line 3922  Line 4008 
4008          close(SBMLOUTPUT);          close(SBMLOUTPUT);
4009  }  }
4010    
4011    =head3 PrintModelSimpleReactionTable
4012    Definition:
4013            success()/fail() FIGMODELmodel->PrintModelSimpleReactionTable();
4014    Description:
4015            Prints the table of model data
4016    =cut
4017    sub PrintModelSimpleReactionTable {
4018            my ($self) = @_;
4019    
4020            my $rxntbl = $self->reaction_table();
4021            my $tbl = $self->create_table_prototype("ModelSimpleReactionTable");
4022            for (my $i=0; $i < $rxntbl->size(); $i++) {
4023                    my $row = $rxntbl->get_row($i);
4024                    $row->{DATABASE} = $row->{LOAD};
4025                    $tbl->add_row($row);
4026            }
4027            $tbl->save();
4028            system("cp ".$tbl->filename()." ".$self->figmodel()->config("Model table download directory")->[0].$self->figmodel()->config("ModelSimpleReactionTable")->{filename_prefix}->[0]."-".$self->id().".txt");
4029    }
4030    
4031  =head3 PrintModelLPFile  =head3 PrintModelLPFile
4032  Definition:  Definition:
4033          success()/fail() FIGMODELmodel->PrintModelLPFile();          success()/fail() FIGMODELmodel->PrintModelLPFile();
# Line 4109  Line 4215 
4215          $self->reaction_table()->save();          $self->reaction_table()->save();
4216  }  }
4217    
4218    =head3 feature_web_data
4219    Definition:
4220            string:web output for feature/model connection = FIGMODELmodel->feature_web_data(FIGMODELfeature:feature);
4221    Description:
4222    =cut
4223    sub feature_web_data {
4224            my ($self,$feature) = @_;
4225    
4226            #First checking if the feature is in the model
4227            my $featureGenome = $feature->{GENOME}->[0];
4228            if ($feature->{GENOME}->[0] =~ m/\>(\d+\.\d+)\</) {
4229                    $featureGenome = $1;
4230            }
4231            if ($featureGenome ne $self->genome()) {
4232                    return "Not in model";
4233            }
4234            my $data = $self->get_feature_data($feature->{ID}->[0]);
4235            if (!defined($data)) {
4236                    return "Not in model";
4237            }
4238    
4239            my $output;
4240            #Printing predictions
4241            if (defined($data->{$self->id()."PREDICTIONS"})) {
4242                    #Parsing essentiality data
4243                    my $essentialityData;
4244                    if (defined($feature->{ESSENTIALITY})) {
4245                            for (my $i=0; $i < @{$feature->{ESSENTIALITY}};$i++) {
4246                                    my @temp = split(/:/,$feature->{ESSENTIALITY}->[$i]);
4247                                    $essentialityData->{$temp[0]} = $temp[1];
4248                            }
4249                    }
4250                    my $predictionHash;
4251                    for (my $i=0; $i < @{$data->{$self->id()."PREDICTIONS"}};$i++) {
4252                            my @temp = split(/:/,$data->{$self->id()."PREDICTIONS"}->[$i]);
4253                            if (defined($essentialityData->{$temp[0]})) {
4254                                    if ($temp[1] eq "essential" && $essentialityData->{$temp[0]} eq "essential") {
4255                                            push(@{$predictionHash->{"Correct negative"}},$temp[0]);
4256                                    } elsif ($temp[1] eq "nonessential" && $essentialityData->{$temp[0]} eq "essential") {
4257                                            push(@{$predictionHash->{"False positive"}},$temp[0]);
4258                                    } elsif ($temp[1] eq "essential" && $essentialityData->{$temp[0]} eq "nonessential") {
4259                                            push(@{$predictionHash->{"False negative"}},$temp[0]);
4260                                    } elsif ($temp[1] eq "nonessential" && $essentialityData->{$temp[0]} eq "nonessential") {
4261                                            push(@{$predictionHash->{"Correct positive"}},$temp[0]);
4262                                    }
4263                            } else {
4264                                    push(@{$predictionHash->{$temp[1]}},$temp[0]);
4265                            }
4266                    }
4267                    foreach my $key (keys(%{$predictionHash})) {
4268                            my $string = $key;
4269                            $string = ucfirst($string);
4270                            push(@{$output},'<span title="'.join(", ",@{$predictionHash->{$key}}).'">'.$string.'</span>');
4271                    }
4272            }
4273    
4274            #Printing reactions
4275            if (defined($data->{$self->id()."REACTIONS"})) {
4276                    for (my $i=0; $i < @{$data->{$self->id()."REACTIONS"}};$i++) {
4277                            my $rxnData = $self->get_reaction_data($data->{$self->id()."REACTIONS"}->[$i]);
4278                            my $reactionString = $self->figmodel()->web()->create_reaction_link($data->{$self->id()."REACTIONS"}->[$i],join(" or ",@{$rxnData->{"ASSOCIATED PEG"}}),$self->id());
4279                            if (defined($rxnData->{PREDICTIONS})) {
4280                                    my $predictionHash;
4281                                    for (my $i=0; $i < @{$rxnData->{PREDICTIONS}};$i++) {
4282                                            my @temp = split(/:/,$rxnData->{PREDICTIONS}->[$i]);
4283                                            push(@{$predictionHash->{$temp[1]}},$temp[0]);
4284                                    }
4285                                    $reactionString .= "(";
4286                                    foreach my $key (keys(%{$predictionHash})) {
4287                                            if ($key eq "Essential =>") {
4288                                                    $reactionString .= '<span title="Essential in '.join(",",@{$predictionHash->{$key}}).'">E=></span>,';
4289                                            } elsif ($key eq "Essential <=") {
4290                                                    $reactionString .= '<span title="Essential in '.join(",",@{$predictionHash->{$key}}).'">E<=</span>,';
4291                                            } elsif ($key eq "Active =>") {
4292                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A=></span>,';
4293                                            } elsif ($key eq "Active <=") {
4294                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A<=</span>,';
4295                                            } elsif ($key eq "Active <=>") {
4296                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A</span>,';
4297                                            } elsif ($key eq "Inactive") {
4298                                                    $reactionString .= '<span title="Inactive in '.join(",",@{$predictionHash->{$key}}).'">I</span>,';
4299                                            } elsif ($key eq "Dead") {
4300                                                    $reactionString .= '<span title="Dead">D</span>,';
4301                                            }
4302                                    }
4303                                    $reactionString =~ s/,$/)/;
4304                            }
4305                            push(@{$output},$reactionString);
4306                    }
4307            }
4308    
4309            #Returning output
4310            return join("<br>",@{$output});
4311    }
4312    
4313    =head3 remove_obsolete_reactions
4314    Definition:
4315            void FIGMODELmodel->remove_obsolete_reactions();
4316    Description:
4317    =cut
4318    sub remove_obsolete_reactions {
4319            my ($self) = @_;
4320    
4321            (my $dummy,my $translation) = $self->figmodel()->put_two_column_array_in_hash($self->figmodel()->database()->load_multiple_column_file($self->figmodel()->config("Translation directory")->[0]."ObsoleteRxnIDs.txt","\t"));
4322            my $rxnTbl = $self->reaction_table();
4323            if (defined($rxnTbl)) {
4324                    for (my $i=0; $i < $rxnTbl->size(); $i++) {
4325                            my $row = $rxnTbl->get_row($i);
4326                            if (defined($translation->{$row->{LOAD}->[0]}) || defined($translation->{$row->{LOAD}->[0]."r"})) {
4327                                    my $direction = $row->{DIRECTION}->[0];
4328                                    my $newRxn;
4329                                    if (defined($translation->{$row->{LOAD}->[0]."r"})) {
4330                                            $newRxn = $translation->{$row->{LOAD}->[0]."r"};
4331                                            if ($direction eq "<=") {
4332                                                    $direction = "=>";
4333                                            } elsif ($direction eq "=>") {
4334                                                    $direction = "<=";
4335                                            }
4336                                    } else {
4337                                            $newRxn = $translation->{$row->{LOAD}->[0]};
4338                                    }
4339                                    #Checking if the new reaction is already in the model
4340                                    my $newRow = $rxnTbl->get_row_by_key($newRxn,"LOAD");
4341                                    if (defined($newRow)) {
4342                                            #Handling direction
4343                                            if ($newRow->{DIRECTION}->[0] ne $direction) {
4344                                                    $newRow->{DIRECTION}->[0] = "<=>";
4345                                            }
4346                                            push(@{$row->{"ASSOCIATED PEG"}},@{$rxnTbl->get_row($i)->{"ASSOCIATED PEG"}});
4347                                    } else {
4348                                            $rxnTbl->get_row($i)->{LOAD}->[0] = $newRxn;
4349                                            $rxnTbl->get_row($i)->{DIRECTION}->[0] = $direction;
4350                                    }
4351                            }
4352                    }
4353                    $rxnTbl->save();
4354            }
4355    }
4356    
4357  1;  1;

Legend:
Removed from v.1.5  
changed lines
  Added in v.1.18

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3