[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.18, Mon May 31 18:05:08 2010 UTC revision 1.29, Mon Aug 30 02:41:43 2010 UTC
# Line 13  Line 13 
13          This is the constructor for the FIGMODELmodel object.          This is the constructor for the FIGMODELmodel object.
14  =cut  =cut
15  sub new {  sub new {
16          my ($class,$figmodel,$id) = @_;          my ($class,$figmodel,$id,$metagenome) = @_;
   
17          #Error checking first          #Error checking first
18          if (!defined($figmodel)) {          if (!defined($figmodel)) {
19                  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 26  Line 25 
25                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,undef):id must be defined to create a model object");                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,undef):id must be defined to create a model object");
26                  return undef;                  return undef;
27          }          }
   
28          #Checking that the id exists          #Checking that the id exists
29            if (!defined($metagenome) || $metagenome != 1) {
30          my $modelHandle = $self->figmodel()->database()->get_object_manager("model");          my $modelHandle = $self->figmodel()->database()->get_object_manager("model");
31          if (!defined($modelHandle)) {                  if (defined($modelHandle)) {
                 $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not load MODELS table. Check database!");  
                 return undef;  
         }  
   
32          #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
33          if ($id =~ m/^\d+$/) {          if ($id =~ m/^\d+$/) {
34                  my $objects = $modelHandle->get_objects();                  my $objects = $modelHandle->get_objects();
35                                    if (defined($objects->[$id])) {
36                  $self->{_data} = $objects->[$id];                  $self->{_data} = $objects->[$id];
37                  $self->figmodel()->{_models}->{$id} = $self;                  $self->figmodel()->{_models}->{$id} = $self;
38                                    }
39          } else {          } else {
40                  my $objects = $modelHandle->get_objects({id => $id});                  my $objects = $modelHandle->get_objects({id => $id});
41                  if (!defined($objects->[0]) && $id =~ m/(.+)(V[^V]+)/) {                                  if (defined($objects->[0])) {
42                                            $self->{_data} = $objects->[0];
43                                    } elsif (!defined($objects->[0]) && $id =~ m/(.+)(V[^V]+)/) {
44                          $objects = $modelHandle->get_objects({id => $1});                          $objects = $modelHandle->get_objects({id => $1});
45                          if (!defined($objects->[0])) {                                          if (defined($objects->[0])) {
                                 $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");  
                                 return undef;  
                         }  
46                          $self->{_selectedversion} = $2;                          $self->{_selectedversion} = $2;
47                  } elsif (!defined($objects->[0])) {                                                  $self->{_data} = $objects->[0];
48                          $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");                                          }
49                          return undef;                                  }
50                            }
51                    }
52                    if (defined($self->{_data})) {
53                            $self->{_modeltype} = "genome";
54                    }
55                  }                  }
56            if (!defined($self->{_data})) {
57                    my $modelHandle = $self->figmodel()->database()->get_object_manager("mgmodel");
58                    if (defined($modelHandle)) {
59                            #If the id is a number, we get the model row by index
60                            if ($id =~ m/^\d+$/) {
61                                    my $objects = $modelHandle->get_objects();
62                                    if (defined($objects->[$id])) {
63                                            $self->{_data} = $objects->[$id];
64                                            $self->figmodel()->{_models}->{"MG".$id} = $self;
65                                    }
66                            } else {
67                                    my $objects = $modelHandle->get_objects({id => $id});
68                                    if (defined($objects->[0])) {
69                  $self->{_data} = $objects->[0];                  $self->{_data} = $objects->[0];
70                                    } elsif (!defined($objects->[0]) && $id =~ m/(.+)(V[^V]+)/) {
71                                            $objects = $modelHandle->get_objects({id => $1});
72                                            if (defined($objects->[0])) {
73                                                    $self->{_selectedversion} = $2;
74                                                    $self->{_data} = $objects->[0];
75                                            }
76                                    }
77                            }
78                    }
79                    if (defined($self->{_data})) {
80                            $self->{_modeltype} = "metagenome";
81                    }
82          }          }
83          if (!defined($self->{_data})) {          if (!defined($self->{_data})) {
84                  $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 model ".$id." in database!");
85                  return undef;                  return undef;
86          }          }
87          $self->figmodel()->{_models}->{$self->id()} = $self;          $self->figmodel()->{_models}->{$self->id()} = $self;
   
88          return $self;          return $self;
89  }  }
90    
# Line 75  Line 100 
100          return $self->figmodel()->config($key);          return $self->figmodel()->config($key);
101  }  }
102    
103    =head3 error_message
104    Definition:
105            string:message text = FIGMODELmodel->error_message(string::message);
106    Description:
107    =cut
108    sub error_message {
109            my ($self,$message) = @_;
110            return $self->figmodel()->error_message("FIGMODELmodel:".$self->id().":".$message);
111    }
112    
113  =head3 fail  =head3 fail
114  Definition:  Definition:
115          -1 = FIGMODELmodel->fail();          -1 = FIGMODELmodel->fail();
# Line 166  Line 201 
201  =cut  =cut
202  sub mgdata {  sub mgdata {
203          my ($self) = @_;          my ($self) = @_;
204          if (!defined($self->{_mgdata}) && $self->source() =~ /^MGRAST/) {          if (!defined($self->{_mgdata})) {
205                  require MGRAST;                  my $mgrastdbhandle = $self->figmodel()->database()->get_object_manager("mgjob");
206                  $self->{_mgdata} = $self->figmodel()->mgrast()->Job->get_objects( { 'genome_id' => $self->genome() } )                  my $objects = $mgrastdbhandle->get_objects( { 'genome_id' => $self->genome() } );
207                    $self->{_mgdata} = $objects->[0];
208          }          }
209          return $self->{_mgdata};          return $self->{_mgdata};
210  }  }
# Line 184  Line 220 
220          return $self->{_data}->id();          return $self->{_data}->id();
221  }  }
222    
223    =head3 get_model_type
224    Definition:
225            string = FIGMODELmodel->get_model_type();
226    Description:
227            Returns the type of the model
228    =cut
229    sub get_model_type {
230            my ($self) = @_;
231            return $self->{_modeltype};
232    }
233    
234  =head3 owner  =head3 owner
235  Definition:  Definition:
236          string = FIGMODELmodel->owner();          string = FIGMODELmodel->owner();
# Line 195  Line 242 
242          return $self->{_data}->owner();          return $self->{_data}->owner();
243  }  }
244    
245    =head3 users
246    Definition:
247            string = FIGMODELmodel->users();
248    Description:
249    =cut
250    sub users {
251            my ($self) = @_;
252            return $self->{_data}->users();
253    }
254    
255  =head3 name  =head3 name
256  Definition:  Definition:
257          string = FIGMODELmodel->name();          string = FIGMODELmodel->name();
# Line 248  Line 305 
305                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
306                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative") {
307                                  $class = "Essential <=";                                  $class = "Essential <=";
308                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$max)." to ".sprintf("%.3g",$min)."]<br>" : $class.="<br>[Flux: ".$max." to ".$min."]<br>";
309                          } elsif ($ClassRow->{CLASS}->[0] eq "Positive variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Positive variable") {
310                                  $class = "Active =>";                                  $class = "Active =>";
311                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
312                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative variable") {
313                                  $class = "Active <=";                                  $class = "Active <=";
314                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$max)." to ".sprintf("%.3g",$min)."]<br>" : $class.="<br>[Flux: ".$max." to ".$min."]<br>";
315                          } elsif ($ClassRow->{CLASS}->[0] eq "Variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Variable") {
316                                  $class = "Active <=>";                                  $class = "Active <=>";
317                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $class.="<br>[Flux: ".$min." to ".$max."]<br>";
# Line 295  Line 352 
352                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
353                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative") {
354                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential <=";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential <=";
355                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$max)." to ".sprintf("%.3g",$min)."]<br>" : $NewClass.="<br>[Flux: ".$max." to ".$min."]<br>";
356                          } elsif ($ClassRow->{CLASS}->[$i] eq "Positive variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Positive variable") {
357                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active =>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active =>";
358                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
359                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative variable") {
360                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=";
361                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$max)." to ".sprintf("%.3g",$min)."]<br>" : $NewClass.="<br>[Flux: ".$max." to ".$min."]<br>";
362                          } elsif ($ClassRow->{CLASS}->[$i] eq "Variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Variable") {
363                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=>";
364                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";                                  $brief_flux ? $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>" : $NewClass.="<br>[Flux: ".$min." to ".$max."]<br>";
# Line 352  Line 409 
409  =cut  =cut
410  sub get_reaction_data {  sub get_reaction_data {
411          my ($self,$reaction) = @_;          my ($self,$reaction) = @_;
   
412          if (!defined($self->reaction_table())) {          if (!defined($self->reaction_table())) {
413                  return undef;                  return undef;
414          }          }
415          if ($reaction =~ m/^\d+$/) {          if ($reaction =~ m/^\d+$/) {
416                  $self->reaction_table()->get_row($reaction);                  return $self->reaction_table()->get_row($reaction);
417          }          }
418          return $self->reaction_table()->get_row_by_key($reaction,"LOAD");          return $self->reaction_table()->get_row_by_key($reaction,"LOAD");
419  }  }
# Line 387  Line 443 
443  =cut  =cut
444  sub load_model_table {  sub load_model_table {
445          my ($self,$name,$refresh) = @_;          my ($self,$name,$refresh) = @_;
446          if (!defined($refresh)) {          if (defined($refresh) && $refresh == 1) {
                 $refresh = 1;  
         }  
         if ($refresh == 1) {  
447                  delete $self->{"_".$name};                  delete $self->{"_".$name};
448          }          }
449          if (!defined($self->{"_".$name})) {          if (!defined($self->{"_".$name})) {
450                  my $tbldef = $self->figmodel()->config("$name");                  my $tbldef = $self->figmodel()->config($name);
451                  if (!defined($tbldef)) {                  if (!defined($tbldef)) {
452                          return undef;                          return undef;
453                  }                  }
454                  my $filename = $self->directory().$name."-".$self->id().$self->selected_version().".tbl";                  my $itemDelim = "|";
455                  $self->{"_".$name} = $self->figmodel()->database()->load_table($filename,"\t","|",$tbldef->{headingline}->[0],$tbldef->{hashcolumns});                  if (defined($tbldef->{itemdelimiter}->[0])) {
456                  if (!defined($self->{"_".$name})) {                          $itemDelim = $tbldef->{itemdelimiter}->[0];
457                            if ($itemDelim eq "SC") {
458                                    $itemDelim = ";";
459                            }
460                    }
461                    my $columnDelim = "\t";
462                    if (defined($tbldef->{columndelimiter}->[0])) {
463                            $columnDelim = $tbldef->{columndelimiter}->[0];
464                            if ($columnDelim eq "SC") {
465                                    $columnDelim = ";";
466                            }
467                    }
468                    my $suffix = ".tbl";
469                    if (defined($tbldef->{filename_suffix}->[0])) {
470                            $suffix = $tbldef->{filename_suffix}->[0];
471                    }
472                    my $filename = $self->directory().$name."-".$self->id().$self->selected_version().$suffix;
473                    if (defined($tbldef->{filename_prefix}->[0])) {
474                            if ($tbldef->{filename_prefix}->[0] eq "NONE") {
475                                    $filename = $self->directory().$self->id().$self->selected_version().$suffix;
476                            } else {
477                                    $filename = $self->directory().$tbldef->{filename_prefix}->[0]."-".$self->id().$self->selected_version().$suffix;
478                            }
479                    }
480                    if (-e $filename) {
481                            $self->{"_".$name} = $self->figmodel()->database()->load_table($filename,$columnDelim,$itemDelim,$tbldef->{headingline}->[0],$tbldef->{hashcolumns});
482                    } else {
483                          if (defined($tbldef->{prefix})) {                          if (defined($tbldef->{prefix})) {
484                                  $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},"\t","|",join(@{$tbldef->{prefix}},"\n"));                                  $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},$columnDelim,$itemDelim,join(@{$tbldef->{prefix}},"\n"));
485                          } else {                          } else {
486                                  $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},"\t","|");                                  $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},$columnDelim,$itemDelim);
487                          }                          }
488                  }                  }
489          }          }
# Line 421  Line 500 
500  =cut  =cut
501  sub create_table_prototype {  sub create_table_prototype {
502          my ($self,$TableName) = @_;          my ($self,$TableName) = @_;
   
503          #Checking if the table definition exists in the FIGMODELconfig file          #Checking if the table definition exists in the FIGMODELconfig file
504          if (!defined($self->figmodel()->config($TableName))) {          my $tbldef = $self->figmodel()->config($TableName);
505            if (!defined($tbldef)) {
506                  $self->figmodel()->error_message("FIGMODELdatabase:create_table_prototype:Definition not found for ".$TableName);                  $self->figmodel()->error_message("FIGMODELdatabase:create_table_prototype:Definition not found for ".$TableName);
507                  return undef;                  return undef;
508          }          }
509          #Checking that this is a database table          #Checking that this is a database table
510          if (!defined($self->config($TableName)->{tabletype}) || $self->config($TableName)->{tabletype}->[0] ne "ModelTable") {          if (!defined($tbldef->{tabletype}) || $tbldef->{tabletype}->[0] ne "ModelTable") {
511                  $self->figmodel()->error_message("FIGMODELdatabase:create_table_prototype:".$TableName." is not a model table!");                  $self->figmodel()->error_message("FIGMODELdatabase:create_table_prototype:".$TableName." is not a model table!");
512                  return undef;                  return undef;
513          }          }
514          if (!defined($self->config($TableName)->{delimiter})) {          #Setting default values for table parameters
515                  $self->config($TableName)->{delimiter}->[0] = ";";          my $prefix;
516            if (defined($tbldef->{prefix})) {
517                    $prefix = join("\n",@{$self->config($TableName)->{prefix}})."\n";
518          }          }
519          if (!defined($self->config($TableName)->{itemdelimiter})) {          my $itemDelim = "|";
520                  $self->config($TableName)->{itemdelimiter}->[0] = "|";          if (defined($tbldef->{itemdelimiter}->[0])) {
521                    $itemDelim = $tbldef->{itemdelimiter}->[0];
522                    if ($itemDelim eq "SC") {
523                            $itemDelim = ";";
524                    }
525            }
526            my $columnDelim = "\t";
527            if (defined($tbldef->{columndelimiter}->[0])) {
528                    $columnDelim = $tbldef->{columndelimiter}->[0];
529                    if ($columnDelim eq "SC") {
530                            $columnDelim = ";";
531          }          }
         my $prefix;  
         if (defined($self->config($TableName)->{prefix})) {  
                 $prefix = join("\n",@{$self->config($TableName)->{prefix}});  
532          }          }
533          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);          my $suffix = ".tbl";
534            if (defined($tbldef->{filename_suffix}->[0])) {
535                    $suffix = $tbldef->{filename_suffix}->[0];
536            }
537            my $filename = $self->directory().$TableName."-".$self->id().$self->selected_version().$suffix;
538            if (defined($tbldef->{filename_prefix}->[0])) {
539                    if ($tbldef->{filename_prefix}->[0] eq "NONE") {
540                            $filename = $self->directory().$self->id().$self->selected_version().$suffix;
541                    } else {
542                            $filename = $self->directory().$tbldef->{filename_prefix}->[0]."-".$self->id().$self->selected_version().$suffix;
543                    }
544            }
545            #Creating the table prototype
546            my $tbl = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},$columnDelim,$itemDelim,$prefix);
547          return $tbl;          return $tbl;
548  }  }
549    
# Line 467  Line 568 
568          Returns FIGMODELTable with the reaction list for the model          Returns FIGMODELTable with the reaction list for the model
569  =cut  =cut
570  sub reaction_table {  sub reaction_table {
571          my ($self) = @_;          my ($self,$clear) = @_;
572            if (defined($clear) && $clear == 1) {
573          if (!defined($self->{_reaction_data})) {                  delete $self->{_reaction_table};
574                  $self->{_reaction_data} = $self->figmodel()->database()->GetDBModel($self->id());          }
575            if (!defined($self->{_reaction_table})) {
576                    $self->{_reaction_table} = $self->load_model_table("ModelReactions",$clear);
577                  my $classTbl = $self->reaction_class_table();                  my $classTbl = $self->reaction_class_table();
578                    if (defined($classTbl)) {
579                  for (my $i=0; $i < $classTbl->size(); $i++) {                  for (my $i=0; $i < $classTbl->size(); $i++) {
580                          my $row = $classTbl->get_row($i);                          my $row = $classTbl->get_row($i);
581                          my $rxnRow = $self->{_reaction_data}->get_row_by_key($row->{"REACTION"}->[0],"LOAD");                                  if (defined($row->{REACTION})) {
582                                            my $rxnRow = $self->{_reaction_table}->get_row_by_key($row->{"REACTION"}->[0],"LOAD");
583                                            if (defined($row->{MEDIA})) {
584                          for (my $j=0; $j < @{$row->{MEDIA}};$j++) {                          for (my $j=0; $j < @{$row->{MEDIA}};$j++) {
585                                  my $class = "Active <=>";                                  my $class = "Active <=>";
586                                  if ($row->{CLASS}->[$j] eq "Positive") {                                  if ($row->{CLASS}->[$j] eq "Positive") {
# Line 496  Line 602 
602                          }                          }
603                  }                  }
604          }          }
605                            }
606                    }
607            }
608            return $self->{_reaction_table};
609    }
610    
611    =head3 essentials_table
612    Definition:
613            FIGMODELTable = FIGMODELmodel->essentials_table();
614    Description:
615            Returns FIGMODELTable with the essential genes for the model
616    =cut
617    sub essentials_table {
618            my ($self,$clear) = @_;
619            my $tbl = $self->load_model_table("ModelEssentialGenes",$clear);
620            return $tbl;
621    }
622    
623          return $self->{_reaction_data};  =head3 model_history
624    Definition:
625            FIGMODELTable = FIGMODELmodel->model_history();
626    Description:
627            Returns FIGMODELTable with the history of model changes
628    =cut
629    sub model_history {
630            my ($self,$clear) = @_;
631            return $self->load_model_table("ModelHistory",$clear);
632  }  }
633    
634  =head3 feature_table  =head3 feature_table
# Line 551  Line 682 
682                  }                  }
683              }              }
684              #Loading predictions              #Loading predictions
685              my @files = glob($self->directory()."EssentialGenes-".$self->id()."-*");                  my $esstbl = $self->essentials_table();
             foreach my $file (@files) {  
                 if ($file =~ m/\-([^\-]+)\.tbl/) {  
                         my $media = $1;  
                         my $list = $self->figmodel()->database()->load_single_column_file($file,"");  
                         my $hash;  
                         foreach my $gene (@{$list}) {  
                                 $hash->{$gene} = 1;  
                         }  
686                          for (my $i=0; $i < $self->{_feature_data}->size(); $i++) {                          for (my $i=0; $i < $self->{_feature_data}->size(); $i++) {
687                                  my $Row = $self->{_feature_data}->get_row($i);                                  my $Row = $self->{_feature_data}->get_row($i);
688                                  if ($Row->{ID}->[0] =~ m/(peg\.\d+)/) {                                  if ($Row->{ID}->[0] =~ m/(peg\.\d+)/) {
689                                          my $gene = $1;                                          my $gene = $1;
690                                          if (defined($hash->{$gene})) {                                  my @rows = $esstbl->get_rows_by_key($gene,"ESSENTIAL GENES");
691                                                  push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":essential");                                  my $mediahash;
692                                    for (my $j=0; $j < $esstbl->size(); $j++) {
693                                            $mediahash->{$esstbl->get_row($j)->{MEDIA}->[0]} = 0;
694                                    }
695                                    for (my $j=0; $j < @rows; $j++) {
696                                            $mediahash->{$rows[$j]->{MEDIA}->[0]} = 1;
697                                    }
698                                    my @mediaList = keys(%{$mediahash});
699                                    for (my $j=0; $j < @mediaList; $j++) {
700                                            if ($mediahash->{$mediaList[$j]} == 1) {
701                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$mediaList[$j].":essential");
702                                          } else {                                          } else {
703                                                  push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":nonessential");                                                  push(@{$Row->{$self->id()."PREDICTIONS"}},$mediaList[$j].":nonessential");
                                         }  
704                                  }                                  }
705                          }                          }
706                  }                  }
# Line 584  Line 716 
716          Returns FIGMODELTable with the reaction class data, and creates the table file  if it does not exist          Returns FIGMODELTable with the reaction class data, and creates the table file  if it does not exist
717  =cut  =cut
718  sub reaction_class_table {  sub reaction_class_table {
719          my ($self) = @_;          my ($self,$clear) = @_;
720            return $self->load_model_table("ModelReactionClasses",$clear);
         if (!defined($self->{_reaction_class_table})) {  
                 if (-e $self->directory()."ReactionClassification-".$self->id().$self->selected_version().".tbl") {  
                         $self->{_reaction_class_table} = $self->figmodel()->database()->load_table($self->directory()."ReactionClassification-".$self->id().$self->selected_version().".tbl",";","|",0,["REACTION","CLASS","MEDIA"]);  
                 } else {  
                         $self->{_reaction_class_table} = FIGMODELTable->new(["REACTION","MEDIA","CLASS","MIN","MAX"],$self->directory()."ReactionClassification-".$self->id().$self->selected_version().".tbl",["REACTION","CLASS","MEDIA"],";","|",undef);  
                 }  
         }  
   
         return $self->{_reaction_class_table};  
721  }  }
722    
723  =head3 compound_class_table  =head3 compound_class_table
# Line 604  Line 727 
727          Returns FIGMODELTable with the compound class data, and creates the table file  if it does not exist          Returns FIGMODELTable with the compound class data, and creates the table file  if it does not exist
728  =cut  =cut
729  sub compound_class_table {  sub compound_class_table {
730          my ($self) = @_;          my ($self,$clear) = @_;
731            return $self->load_model_table("ModelCompoundClasses",$clear);
         if (!defined($self->{_compound_class_table})) {  
                 if (-e $self->directory()."CompoundClassification-".$self->id().$self->selected_version().".tbl") {  
                         $self->{_compound_class_table} = $self->figmodel()->database()->load_table($self->directory()."CompoundClassification-".$self->id().$self->selected_version().".tbl",";","|",0,["COMPOUND","CLASS","MEDIA"]);  
                 } else {  
                         $self->{_compound_class_table} = FIGMODELTable->new(["COMPOUND","MEDIA","CLASS","MIN","MAX"],$self->directory()."CompoundClassification-".$self->id().$self->selected_version().".tbl",["COMPOUND","CLASS","MEDIA"],";","|",undef);  
                 }  
         }  
   
         return $self->{_compound_class_table};  
732  }  }
733    
734  =head3 get_essential_genes  =head3 get_essential_genes
# Line 625  Line 739 
739  =cut  =cut
740  sub get_essential_genes {  sub get_essential_genes {
741          my ($self,$media) = @_;          my ($self,$media) = @_;
742            my $tbl = $self->essentials_table();
743          if (!defined($media)) {          my $row = $tbl->get_row_by_key($media,"MEDIA");
744                  $media = "Complete";          if (defined($row)) {
745          }                  return $row->{"ESSENTIAL GENES"};
         if (!defined($self->{_essential_genes}->{$media})) {  
                 $self->{_essential_genes}->{$media} = undef;  
                 if (-e $self->directory()."EssentialGenes-".$self->id().$self->selected_version()."-".$media.".tbl") {  
                         $self->{_essential_genes}->{$media} = $self->figmodel()->database()->load_single_column_file($self->directory()."EssentialGenes-".$self->id().$self->selected_version()."-".$media.".tbl","");  
746                  }                  }
747          }          return undef;
   
         return $self->{_essential_genes}->{$media};  
748  }  }
749    
750  =head3 compound_table  =head3 compound_table
# Line 649  Line 757 
757          my ($self) = @_;          my ($self) = @_;
758    
759          if (!defined($self->{_compound_table})) {          if (!defined($self->{_compound_table})) {
760                  $self->{_compound_table} = $self->figmodel()->database()->GetDBModelCompounds($self->id());                  $self->{_compound_table} = $self->create_table_prototype("ModelCompounds");
761                    #Loading the reactions
762                    my $ReactionTable = $self->figmodel()->database()->get_table("REACTIONS");
763                    my $BiomassTable = $self->figmodel()->database()->get_table("BIOMASS");
764                    #Loading the model
765                    my $ModelTable = $self->reaction_table();
766                    #Checking that the tables were loaded
767                    if (!defined($ModelTable) || !defined($ReactionTable)) {
768                            return undef;
769                    }
770                    #Finding the biomass reaction
771                    for (my $i=0; $i < $ModelTable->size(); $i++) {
772                            my $ID = $ModelTable->get_row($i)->{"LOAD"}->[0];
773                            my $Row = $ReactionTable->get_row_by_key($ID,"DATABASE");
774                            my $IsBiomass = 0;
775                            if (!defined($Row)) {
776                                    $Row = $BiomassTable->get_row_by_key($ID,"DATABASE");
777                                    $IsBiomass = 1;
778                            }
779                            if (defined($Row->{"EQUATION"}->[0])) {
780                                    $_ = $Row->{"EQUATION"}->[0];
781                                    my @OriginalArray = /(cpd\d\d\d\d\d[\[\w]*)/g;
782                                    foreach my $Compound (@OriginalArray) {
783                                            my $ID = substr($Compound,0,8);
784                                            my $NewRow = $self->{_compound_table}->get_row_by_key($ID,"DATABASE",1);
785                                            if ($IsBiomass == 1) {
786                                                    $self->{_compound_table}->add_data($NewRow,"BIOMASS",$Row->{"DATABASE"}->[0],1);
787                                            }
788                                            if (length($Compound) > 8) {
789                                                    #print $Compound."\t".$Row->{"EQUATION"}->[0]."\t".$Row->{"DATABASE"}->[0]."\n";
790                                                    my $Compartment = substr($Compound,8,1);
791                                                    $self->{_compound_table}->add_data($NewRow,"COMPARTMENTS",$Compartment,1);
792                                                    $self->{_compound_table}->add_data($NewRow,"TRANSPORTERS",$Row->{"DATABASE"}->[0],1);
793                                            }
794                                    }
795                            }
796                    }
797          }          }
798    
799          return $self->{_compound_table};          return $self->{_compound_table};
# Line 769  Line 913 
913                  }                  }
914                  my $source = $self->source();                  my $source = $self->source();
915                  if ($source =~ /^MGRAST/) {                  if ($source =~ /^MGRAST/) {
916                          $self->{_directory} = $self->figmodel()->config("organism directory")->[0].$userdirectory.$self->genome()."/";                          $self->{_directory} = $self->figmodel()->config("mgrast model directory")->[0].$userdirectory.$self->genome()."/";
917                  } elsif ($source =~ /^RAST/) {                  } elsif ($source =~ /^RAST/) {
918                          $self->{_directory} = $self->figmodel()->config("organism directory")->[0].$userdirectory.$self->genome()."/";                          $self->{_directory} = $self->figmodel()->config("organism directory")->[0].$userdirectory.$self->genome()."/";
919                  } elsif ($source =~ /^SEED/) {                  } elsif ($source =~ /^SEED/) {
# Line 909  Line 1053 
1053          return $self->{_data}->cellwalltype();          return $self->{_data}->cellwalltype();
1054  }  }
1055    
1056    sub autocompleteMedia {
1057            my ($self,$newMedia) = @_;
1058            if (defined($newMedia)) {
1059                    return $self->{_data}->autoCompleteMedia($newMedia);
1060            }
1061            return $self->{_data}->autoCompleteMedia();
1062    }
1063    
1064    sub biomassReaction {
1065            my ($self,$newBiomass) = @_;
1066            if (!defined($newBiomass)) {
1067                    return $self->{_data}->biomassReaction();
1068            } else {
1069                    #Figuring out what the old biomass is
1070                    my $oldBiomass = $self->{_data}->biomassReaction();
1071                    $self->{_data}->biomassReaction($newBiomass);
1072                    #Changing the biomass reaction in the model file
1073                    my $rxnTbl = $self->reaction_table();
1074                    for (my $i=0; $i < $rxnTbl->size(); $i++) {
1075                            my $row = $rxnTbl->get_row($i);
1076                            if ($row->{LOAD}->[0] =~ m/^bio/) {
1077                                    $row->{LOAD}->[0] = $newBiomass;
1078                            }
1079                    }
1080                    $rxnTbl->save();
1081                    if ($newBiomass ne $oldBiomass) {
1082                            #Figuring out if the new biomass exists
1083                            my $handle = $self->figmodel()->database()->get_object_manager("bof");
1084                            my $objects = $handle->get_objects({id=>$newBiomass});
1085                            if (!defined($objects) || !defined($objects->[0])) {
1086                                    print STDERR "Could not find new biomass reaction ".$newBiomass."\n";
1087                                    return $oldBiomass;
1088                            }
1089                    }
1090                    return $newBiomass;
1091            }
1092    }
1093    
1094    =head3 growth
1095    Definition:
1096            double = FIGMODELmodel->growth();
1097    Description:
1098    =cut
1099    sub growth {
1100            my ($self,$inGrowth) = @_;
1101            if (!defined($inGrowth)) {
1102                    return $self->{_data}->growth();
1103            } else {
1104                    return $self->{_data}->growth($inGrowth);
1105            }
1106    }
1107    
1108    =head3 noGrowthCompounds
1109    Definition:
1110            string = FIGMODELmodel->noGrowthCompounds();
1111    Description:
1112    =cut
1113    sub noGrowthCompounds {
1114            my ($self,$inCompounds) = @_;
1115            if (!defined($inCompounds)) {
1116                    return $self->{_data}->noGrowthCompounds();
1117            } else {
1118                    return $self->{_data}->noGrowthCompounds($inCompounds);
1119            }
1120    }
1121    
1122  =head3 taxonomy  =head3 taxonomy
1123  Definition:  Definition:
1124          string = FIGMODELmodel->taxonomy();          string = FIGMODELmodel->taxonomy();
# Line 992  Line 1202 
1202    
1203          #Assuming complete media if none is provided          #Assuming complete media if none is provided
1204          if (!defined($Media)) {          if (!defined($Media)) {
1205                  $Media = "Complete";                  $Media = $self->autocompleteMedia();
1206          }          }
1207    
1208          #Predicting essentiality          #Predicting essentiality
1209          my $result = $self->figmodel()->RunFBASimulation($self->id(),"SINGLEKO",undef,undef,[$self->id()],[$Media]);          my $result = $self->figmodel()->RunFBASimulation($self->id(),"SINGLEKO",undef,undef,[$self->id()],[$Media]);
1210          #Checking that the table is defined and the output file exists          #Checking that the table is defined and the output file exists
1211          if (defined($result) && defined($result->get_row(0)->{"ESSENTIALGENES"})) {          if (defined($result) && defined($result->get_row(0)->{"ESSENTIALGENES"})) {
1212                  $self->figmodel()->database()->print_array_to_file($self->directory()."EssentialGenes-".$self->id()."-".$Media.".tbl",[join("\n",@{$result->get_row(0)->{"ESSENTIALGENES"}})]);                  my $tbl = $self->essentials_table();
1213                    my $row = $tbl->get_row_by_key($Media,"MEDIA",1);
1214                    $row->{"ESSENTIAL GENES"} = $result->get_row(0)->{"ESSENTIALGENES"};
1215                    $tbl->save();
1216          } else {          } else {
1217                  $self->figmodel()->error_message("FIGMODELmodel:run_default_model_predictions:could not identify essential reactions for model ".$self->id().$self->selected_version().".");                  $self->figmodel()->error_message("FIGMODELmodel:run_default_model_predictions:could not identify essential reactions for model ".$self->id().$self->selected_version().".");
1218                  return $self->figmodel()->fail();                  return $self->figmodel()->fail();
# Line 1028  Line 1241 
1241          $self->{_data}->modificationDate(time());          $self->{_data}->modificationDate(time());
1242          my $version = $self->{_data}->autocompleteVersion();          my $version = $self->{_data}->autocompleteVersion();
1243          $self->{_data}->autocompleteVersion($version+1);          $self->{_data}->autocompleteVersion($version+1);
1244            $self->update_model_stats();
1245  }  }
1246    
1247  =head3 update_stats_for_build  =head3 update_stats_for_build
# Line 1041  Line 1255 
1255          $self->{_data}->modificationDate(time());          $self->{_data}->modificationDate(time());
1256          my $version = $self->{_data}->version();          my $version = $self->{_data}->version();
1257          $self->{_data}->version($version+1);          $self->{_data}->version($version+1);
1258            $self->update_model_stats();
1259  }  }
1260    
1261  =head3 update_model_stats  =head3 update_model_stats
# Line 1054  Line 1269 
1269          #Getting reaction table          #Getting reaction table
1270          my $rxntbl = $self->reaction_table();          my $rxntbl = $self->reaction_table();
1271          if (!defined($rxntbl)) {          if (!defined($rxntbl)) {
1272                  $self->figmodel()->error_message("FIGMODELmodel:update_model_stats:Could not load reaction list for ".$self->id());                  die $self->error_message("update_model_stats:Could not load reaction list!");
                 return undef;  
1273          }          }
1274          my $cpdtbl = $self->compound_table();          my $cpdtbl = $self->compound_table();
1275    
# Line 1109  Line 1323 
1323          #Setting the reaction count          #Setting the reaction count
1324          $self->{_data}->reactions($rxntbl->size());          $self->{_data}->reactions($rxntbl->size());
1325          #Setting the metabolite count          #Setting the metabolite count
1326          $self->{_data}->compounds($rxntbl->size());          $self->{_data}->compounds($cpdtbl->size());
1327          #Setting the gene count          #Setting the gene count
1328          my $geneCount = @genes + @othergenes;          my $geneCount = @genes + @othergenes;
1329          $self->{_data}->associatedGenes($geneCount);          $self->{_data}->associatedGenes($geneCount);
# Line 1159  Line 1373 
1373          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
1374          my $StartTime = time();          my $StartTime = time();
1375    
1376          #Archiving the existing model          #Reading original reaction table
1377          $self->ArchiveModel();          my $OriginalRxn = $self->reaction_table();
1378            #Clearing the table
1379            $self->reaction_table(1);
1380    
1381          #Removing any gapfilling reactions that may be currently present in the model          #Removing any gapfilling reactions that may be currently present in the model
1382          if (!defined($donotclear) || $donotclear != 1) {          if (!defined($donotclear) || $donotclear != 1) {
1383                  my $ModelTable = $self->reaction_table();                  my $ModelTable = $self->reaction_table();
1384                  for (my $i=0; $i < $ModelTable->size(); $i++) {                  for (my $i=0; $i < $ModelTable->size(); $i++) {
1385                          if (!defined($ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0]) || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] eq "GAP FILLING" || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] =~ m/BIOLOG/ || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] =~ m/GROWMATCH/) {                          if (!defined($ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0]) || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] eq "AUTOCOMPLETION" || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] eq "GAP FILLING" || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] =~ m/BIOLOG/ || $ModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] =~ m/GROWMATCH/) {
1386                                  $ModelTable->delete_row($i);                                  $ModelTable->delete_row($i);
1387                                  $i--;                                  $i--;
1388                          }                          }
# Line 1175  Line 1391 
1391          }          }
1392    
1393          #Calling the MFAToolkit to run the gap filling optimization          #Calling the MFAToolkit to run the gap filling optimization
1394          my $MinimalMediaTable = $self->figmodel()->database()->GetDBTable("MINIMAL MEDIA TABLE");          my $Media = $self->autocompleteMedia();
1395          my $Media = "Complete";          if ($Media eq "Complete") {
1396          if (defined($MinimalMediaTable->get_row_by_key($self->genome(),"Organism"))) {                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),undef,["GapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0]},"GapFill".$self->id().".log",undef));
1397                  $Media = $MinimalMediaTable->get_row_by_key($self->genome(),"Organism")->{"Minimal media"}->[0];          } else {
1398                  #Loading media, changing bounds, saving media as a test media                  #Loading media, changing bounds, saving media as a test media
1399                  my $MediaTable = FIGMODELTable::load_table($self->config("Media directory")->[0].$Media.".txt",";","",0,["VarName"]);                  my $MediaTable = FIGMODELTable::load_table($self->config("Media directory")->[0].$Media.".txt",";","",0,["VarName"]);
1400                  for (my $i=0; $i < $MediaTable->size(); $i++) {                  for (my $i=0; $i < $MediaTable->size(); $i++) {
# Line 1190  Line 1406 
1406                          }                          }
1407                  }                  }
1408                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1409                    #print $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)."\n";
1410                  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));                  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));
1411                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
         } else {  
                 system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),undef,["GapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0]},"GapFill".$self->id().".log",undef));  
1412          }          }
1413    
1414          #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
1415          my $SolutionData = $self->figmodel()->LoadProblemReport($UniqueFilename);          my $SolutionData = $self->figmodel()->LoadProblemReport($UniqueFilename);
1416    
1417          #Clearing the mfatoolkit output and log file          #Clearing the mfatoolkit output and log file
1418          $self->figmodel()->clearing_output($UniqueFilename,"GapFill".$self->id().".log");          $self->figmodel()->clearing_output($UniqueFilename,"GapFill".$self->id().".log");
1419          if (!defined($SolutionData) || $SolutionData->size() == 0) {          if (!defined($SolutionData) || $SolutionData->size() == 0) {
# Line 1205  Line 1421 
1421                  $self->figmodel()->error_message("FIGMODEL:GapFillModel: Gap filling report not found!");                  $self->figmodel()->error_message("FIGMODEL:GapFillModel: Gap filling report not found!");
1422                  return $self->fail();                  return $self->fail();
1423          }          }
         $SolutionData->save("/home/chenry/Solution.txt");  
1424    
1425          #Looking for the last printed recursive MILP solution          #Looking for the last printed recursive MILP solution
1426          for (my $i=($SolutionData->size()-1); $i >=0; $i--) {          for (my $i=($SolutionData->size()-1); $i >=0; $i--) {
# Line 1233  Line 1448 
1448                                                  push(@{$ReactionList},$ID);                                                  push(@{$ReactionList},$ID);
1449                                          }                                          }
1450                                  }                                  }
1451                                  $self->figmodel()->IntegrateGrowMatchSolution($self->id(),undef,$ReactionList,$DirectionList,"GAP FILLING",0,1);                                  $self->figmodel()->IntegrateGrowMatchSolution($self->id(),undef,$ReactionList,$DirectionList,"AUTOCOMPLETION",0,1);
1452                          }                          }
1453                          last;                          last;
1454                  }                  }
1455          }          }
1456    
1457          #Updating model stats with gap filling results          #Updating model stats with gap filling results
1458          my $ElapsedTime = time() - $StartTime;          my $ElapsedTime = time() - $StartTime;
1459          $self->figmodel()->database()->ClearDBModel($self->id(),1);          $self->reaction_table(1);
1460            $self->calculate_model_changes($OriginalRxn,"AUTOCOMPLETION");
1461    
1462          #Determining why each gap filling reaction was added          #Determining why each gap filling reaction was added
1463          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);
1464          if (!defined($donotclear) || $donotclear != 1) {          if (!defined($donotclear) || $donotclear != 1) {
                 $self->figmodel()->AddBiologTransporters($self->id());  
1465                  if ($self->id() !~ m/MGRast/) {                  if ($self->id() !~ m/MGRast/) {
1466                          $self->update_stats_for_gap_filling($ElapsedTime);                          $self->update_stats_for_gap_filling($ElapsedTime);
1467                  }                  }
# Line 1260  Line 1477 
1477          return $self->success();          return $self->success();
1478  }  }
1479    
1480    =head3 calculate_model_changes
1481    Definition:
1482            FIGMODELmodel->calculate_model_changes(FIGMODELTable:original reaction table,string:modification cause);
1483    Description:
1484    
1485    =cut
1486    
1487    sub calculate_model_changes {
1488            my ($self,$originalReactions,$cause,$tbl,$version) = @_;
1489            my $modTime = time();
1490            if (!defined($version)) {
1491                    $version = $self->selected_version();
1492            }
1493            my $user = $self->figmodel()->user();
1494            #Getting the history table
1495            my $histTbl = $self->model_history();
1496            #Checking for differences
1497            if (!defined($tbl)) {
1498                    $tbl = $self->reaction_table();
1499            }
1500            for (my $i=0; $i < $tbl->size(); $i++) {
1501                    my $row = $tbl->get_row($i);
1502                    my $orgRow = $originalReactions->get_row_by_key($row->{LOAD}->[0],"LOAD");
1503                    if (!defined($orgRow)) {
1504                            $histTbl->add_row({Reaction => [$row->{LOAD}->[0]], DirectionChange => $row->{DIRECTIONALITY}, GeneChange => $row->{"ASSOCIATED PEG"}, Action => ["ADDED"], ModificationTime => [$modTime], ModifcationCause => [$cause], User => [$user], Version => [$version]});
1505                    } else {
1506                            my $geneChanges;
1507                            my $directionChange;
1508                            if ($orgRow->{"DIRECTIONALITY"}->[0] ne $row->{"DIRECTIONALITY"}->[0]) {
1509                                    $directionChange = $orgRow->{"DIRECTIONALITY"}->[0]." to ".$row->{"DIRECTIONALITY"}->[0];
1510                            }
1511                            for (my $j=0; $j < @{$row->{"ASSOCIATED PEG"}}; $j++) {
1512                                    my $match = 0;
1513                                    if (defined($orgRow->{"ASSOCIATED PEG"})) {
1514                                            for (my $k=0; $k < @{$orgRow->{"ASSOCIATED PEG"}}; $k++) {
1515                                                    if ($row->{"ASSOCIATED PEG"}->[$j] eq $orgRow->{"ASSOCIATED PEG"}->[$k]) {
1516                                                            $match = 1;
1517                                                    }
1518                                            }
1519                                    }
1520                                    if ($match == 0) {
1521                                            push(@{$geneChanges},"Added ".$row->{"ASSOCIATED PEG"}->[$j]);
1522                                    }
1523                            }
1524                            if (defined($orgRow->{"ASSOCIATED PEG"})) {
1525                                    for (my $k=0; $k < @{$orgRow->{"ASSOCIATED PEG"}}; $k++) {
1526                                            my $match = 0;
1527                                            if (defined($row->{"ASSOCIATED PEG"})) {
1528                                                    for (my $j=0; $j < @{$row->{"ASSOCIATED PEG"}}; $j++) {
1529                                                            if ($row->{"ASSOCIATED PEG"}->[$j] eq $orgRow->{"ASSOCIATED PEG"}->[$k]) {
1530                                                                    $match = 1;
1531                                                            }
1532                                                    }
1533                                            }
1534                                            if ($match == 0) {
1535                                                    push(@{$geneChanges},"Removed ".$orgRow->{"ASSOCIATED PEG"}->[$k]);
1536                                            }
1537                                    }
1538                            }
1539                            if ((defined($directionChange) && length($directionChange) > 0) || defined($geneChanges) && @{$geneChanges} > 0) {
1540                                    $histTbl->add_row({Reaction => [$row->{LOAD}->[0]], DirectionChange => [$directionChange], GeneChange => $geneChanges, Action => ["CHANGE"], ModificationTime => [$modTime], ModifcationCause => [$cause], User => [$user], Version => [$version]});
1541                            }
1542                    }
1543            }
1544            #Looking for removed reactions
1545            for (my $i=0; $i < $originalReactions->size(); $i++) {
1546                    my $row = $originalReactions->get_row($i);
1547                    my $orgRow = $tbl->get_row_by_key($row->{LOAD}->[0],"LOAD");
1548                    if (!defined($orgRow)) {
1549                            $histTbl->add_row({Reaction => [$row->{LOAD}->[0]], DirectionChange => $row->{DIRECTIONALITY}, GeneChange => $row->{"ASSOCIATED PEG"}, Action => ["REMOVED"], ModificationTime => [$modTime], ModifcationCause => [$cause], User => [$user], Version => [$version]});
1550                    }
1551            }
1552            $histTbl->save();
1553    }
1554    
1555  =head3 GapGenModel  =head3 GapGenModel
1556  Definition:  Definition:
1557          FIGMODELmodel->GapGenModel();          FIGMODELmodel->GapGenModel();
# Line 1497  Line 1789 
1789  =cut  =cut
1790  sub status {  sub status {
1791          my ($self) = @_;          my ($self) = @_;
1792          return $self->{_data}->{status}->[0];          return $self->{_data}->status();
1793  }  }
1794    
1795  =head3 message  =head3 message
# Line 1508  Line 1800 
1800  =cut  =cut
1801  sub message {  sub message {
1802          my ($self) = @_;          my ($self) = @_;
1803          return $self->{_data}->{message}->[0];          return $self->{_data}->message();
1804  }  }
1805    
1806  =head3 set_status  =head3 set_status
# Line 1523  Line 1815 
1815  =cut  =cut
1816  sub set_status {  sub set_status {
1817          my ($self,$NewStatus,$Message) = @_;          my ($self,$NewStatus,$Message) = @_;
1818            $self->{_data}->status($NewStatus);
1819          #Getting the model row from the MODELS table          $self->{_data}->message($Message);
         $self->{_data}->{status}->[0] = $NewStatus;  
         $self->{_data}->{message}->[0] = $Message;  
         $self->figmodel()->database()->update_row("MODELS",$self->{_data},"id");  
1820          return $self->config("SUCCESS")->[0];          return $self->config("SUCCESS")->[0];
1821  }  }
1822    
1823  =head3 CreateSingleGenomeReactionList  =head3 generate_gpr_hash
1824  Definition:  Definition:
1825          FIGMODEL->CreateSingleGenomeReactionList();          FIGMODELmodel->generate_gpr_hash();
1826  Description:  Description:
         This function uses fig calls to obtain a list of genes and functions for a genome, and it uses a file mapping reactions and functional roles to produce a reaction list.  
 Example:  
1827  =cut  =cut
1828    
1829  sub CreateSingleGenomeReactionList {  sub generate_gpr_hash {
1830          my ($self,$RunGapFilling) = @_;          my ($self) = @_;
   
         #Creating directory  
         if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/") {  
                 system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/");  
         } elsif ($self->owner() eq "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->genome()."/") {  
                 system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->genome()."/");  
         }  
         if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/") {  
                 system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/");  
         }  
   
1831          #Getting genome stats          #Getting genome stats
1832          my $genomestats = $self->figmodel()->get_genome_stats($self->genome());          my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
1833          my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());          my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
1834          if (!defined($FeatureTable)) {          if (!defined($FeatureTable)) {
1835                  $self->figmodel()->error_message("FIGMODEL:CreateSingleGenomeReactionList: ".$self->id()." genome features could not be accessed!");                  $self->error_message("generate_gpr_hash:genome features could not be accessed!");
1836                  return $self->fail();                  return undef;
1837          }          }
1838          #Checking that the number of genes exceeds the minimum size          #Checking that the number of genes exceeds the minimum size
1839          if ($FeatureTable->size() < $self->config("minimum genome size for modeling")->[0]) {          if ($FeatureTable->size() < $self->config("minimum genome size for modeling")->[0]) {
1840                  $self->figmodel()->error_message("FIGMODEL:CreateSingleGenomeReactionList: ".$self->id()." genome rejected as too small for modeling!");                  $self->error_message("generate_gpr_hash:genome rejected as too small for modeling!");
1841                  return $self->fail();                  return undef;
         }  
         #Setting up needed variables  
         my $OriginalModelTable = undef;  
         #Locking model status table  
         my $ModelTable = $self->figmodel()->database()->LockDBTable("MODELS");  
         my $Row = $ModelTable->get_row_by_key($self->id(),"id");  
         if (!defined($Row) || !defined($Row->{status}->[0])) {  
                 $self->figmodel()->database()->UnlockDBTable("MODELS");  
                 $self->figmodel()->error_message("FIGMODEL:CreateSingleGenomeReactionList: ".$self->id()." has no row in models table!");  
                 return $self->fail();  
         } elsif ($Row->{status}->[0] == 0) {  
                 $self->figmodel()->error_message("FIGMODEL:CreateSingleGenomeReactionList:Model is already being built. Canceling current build.");  
                 $self->figmodel()->database()->UnlockDBTable("MODELS");  
                 return $self->fail();  
         }elsif ($Row->{status}->[0] == 1) {  
                 $OriginalModelTable = $self->reaction_table();  
                 $self->ArchiveModel();  
                 $Row->{status}->[0] = 0;  
                 $Row->{message}->[0] = "Rebuilding preliminary reconstruction";  
         } else {  
                 $Row->{status}->[0] = 0;  
                 $Row->{message}->[0] = "Preliminary reconstruction";  
1842          }          }
         #Updating the status table  
         $self->figmodel()->database()->save_table($ModelTable);  
         $self->figmodel()->database()->UnlockDBTable("MODELS");  
1843          #Sorting GenomeData by gene location on the chromosome          #Sorting GenomeData by gene location on the chromosome
1844            my $ftrTbl = $self->figmodel()->database()->get_table("ROLERXNMAPPING");
1845          $FeatureTable->sort_rows("MIN LOCATION");          $FeatureTable->sort_rows("MIN LOCATION");
1846          my ($ComplexHash,$SuggestedMappings,$UnrecognizedReactions,$ReactionHash);          my ($ComplexHash,$SuggestedMappings,$UnrecognizedReactions,$ReactionHash);
1847          my %LastGenePosition;          my %LastGenePosition;
# Line 1661  Line 1913 
1913                          }                          }
1914                  }                  }
1915          }          }
   
1916          #Creating nonadjacent complexes          #Creating nonadjacent complexes
1917          my @ReactionList = keys(%{$ReactionHash});          my @ReactionList = keys(%{$ReactionHash});
1918          foreach my $Reaction (@ReactionList) {          foreach my $Reaction (@ReactionList) {
# Line 1746  Line 1997 
1997                          @{$ReactionHash->{$Reaction}->{"GENES"}} = $self->figmodel()->remove_duplicates(@{$GeneArray});                          @{$ReactionHash->{$Reaction}->{"GENES"}} = $self->figmodel()->remove_duplicates(@{$GeneArray});
1998                  }                  }
1999          }          }
2000            return $ReactionHash;
2001    }
2002    
2003    =head3 CreateSingleGenomeReactionList
2004    Definition:
2005            FIGMODELmodel->CreateSingleGenomeReactionList();
2006    Description:
2007            This function uses fig calls to obtain a list of genes and functions for a genome, and it uses a file mapping reactions and functional roles to produce a reaction list.
2008    Example:
2009    =cut
2010    
2011    sub CreateSingleGenomeReactionList {
2012            my ($self,$RunGapFilling) = @_;
2013            #Creating directory
2014            if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/") {
2015                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/");
2016            } elsif ($self->owner() eq "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->genome()."/") {
2017                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->genome()."/");
2018            }
2019            if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/") {
2020                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/");
2021            }
2022            #Checking that the number of genes exceeds the minimum size
2023            my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
2024            if ($FeatureTable->size() < $self->config("minimum genome size for modeling")->[0]) {
2025                    $self->figmodel()->error_message("FIGMODEL:CreateSingleGenomeReactionList: ".$self->id()." genome rejected as too small for modeling!");
2026                    return $self->fail();
2027            }
2028            #Setting up needed variables
2029            my $OriginalModelTable = undef;
2030            if ($self->status() == 0) {
2031                    $self->figmodel()->error_message("FIGMODEL:CreateSingleGenomeReactionList:Model is already being built. Canceling current build.");
2032                    return $self->fail();
2033            }elsif ($self->status() == 1) {
2034                    $OriginalModelTable = $self->reaction_table();
2035                    $self->set_status(0,"Rebuilding preliminary reconstruction");
2036            } else {
2037                    $self->set_status(0,"Preliminary reconstruction");
2038            }
2039            #Getting reaction hash
2040            my $ReactionHash = $self->generate_gpr_hash();
2041            if (!defined($ReactionHash)) {
2042                    $self->figmodel()->error_message("CreateSingleGenomeReactionList:unable to create reaction hash!");
2043                    return $self->fail();
2044            }
2045          #Getting the reaction table          #Getting the reaction table
2046          my $ReactionTable = $self->figmodel()->database()->GetDBTable("REACTIONS");          my $ReactionTable = $self->figmodel()->database()->GetDBTable("REACTIONS");
   
2047          #Creating the model reaction table          #Creating the model reaction table
2048          my $NewModelTable = FIGMODELTable->new(["LOAD","DIRECTIONALITY","COMPARTMENT","ASSOCIATED PEG","SUBSYSTEM","CONFIDENCE","REFERENCE","NOTES"],$self->directory().$self->id().".txt",["LOAD"],";","|","REACTIONS\n");          my $NewModelTable = FIGMODELTable->new(["LOAD","DIRECTIONALITY","COMPARTMENT","ASSOCIATED PEG","SUBSYSTEM","CONFIDENCE","REFERENCE","NOTES"],$self->directory().$self->id().".txt",["LOAD"],";","|","REACTIONS\n");
2049          @ReactionList = keys(%{$ReactionHash});          my @ReactionList = keys(%{$ReactionHash});
2050          foreach my $ReactionID (@ReactionList) {          foreach my $ReactionID (@ReactionList) {
2051                  #Getting the thermodynamic reversibility from the database                  #Getting the thermodynamic reversibility from the database
2052                  my $Directionality = $self->figmodel()->reversibility_of_reaction($ReactionID);                  my $Directionality = $self->figmodel()->reversibility_of_reaction($ReactionID);
# Line 1766  Line 2060 
2060                  }                  }
2061                  $NewModelTable->add_row({"LOAD" => [$ReactionID],"DIRECTIONALITY" => [$Directionality],"COMPARTMENT" => ["c"],"ASSOCIATED PEG" => [join("|",@{$ReactionHash->{$ReactionID}->{"GENES"}})],"SUBSYSTEM" => [$Subsystem],"CONFIDENCE" => [$ReactionHash->{$ReactionID}->{"CONFIDENCE"}->[0]],"REFERENCE" => [$Source],"NOTES" => ["NONE"]});                  $NewModelTable->add_row({"LOAD" => [$ReactionID],"DIRECTIONALITY" => [$Directionality],"COMPARTMENT" => ["c"],"ASSOCIATED PEG" => [join("|",@{$ReactionHash->{$ReactionID}->{"GENES"}})],"SUBSYSTEM" => [$Subsystem],"CONFIDENCE" => [$ReactionHash->{$ReactionID}->{"CONFIDENCE"}->[0]],"REFERENCE" => [$Source],"NOTES" => ["NONE"]});
2062          }          }
2063            #Getting feature rows for features that are lumped
2064            my $ftrTbl = $self->figmodel()->database()->get_table("ROLERXNMAPPING");
2065            my @rows = $ftrTbl->get_rows_by_key("2","MASTER");
2066            for (my $i=0; $i < @rows; $i++) {
2067                    my $rxn = $rows[$i]->{REACTION}->[0];
2068                    my $role = $rows[$i]->{ROLE}->[0];
2069                    my @orgrows = $FeatureTable->get_rows_by_key($role,"ROLES");
2070                    my $genes;
2071                    for (my $j=0; $j < @orgrows; $j++) {
2072                            if ($orgrows[$j]->{ID}->[0] =~ m/(peg\.\d+)/) {
2073                                    push(@{$genes},$1);
2074                            }
2075                    }
2076                    if (defined($genes) && @{$genes} > 0) {
2077                            my $row = $NewModelTable->get_row_by_key($rxn,"LOAD");
2078                            my $newGeneAssociations;
2079                            for (my $k=0; $k < @{$genes}; $k++) {
2080                                    for (my $j=0; $j < @{$row->{"ASSOCIATED PEG"}}; $j++) {
2081                                            my $peg = $genes->[$k];
2082                                            if ($row->{"ASSOCIATED PEG"}->[$j] !~ m/$peg/) {
2083                                                    push(@{$newGeneAssociations},$row->{"ASSOCIATED PEG"}->[$j]."+".$peg);
2084                                            }
2085                                    }
2086                            }
2087                            $row->{"ASSOCIATED PEG"} = $newGeneAssociations;
2088                    }
2089            }
2090          #Adding the spontaneous and universal reactions          #Adding the spontaneous and universal reactions
2091          foreach my $ReactionID (@{$self->config("spontaneous reactions")}) {          foreach my $ReactionID (@{$self->config("spontaneous reactions")}) {
2092                  #Getting the thermodynamic reversibility from the database                  #Getting the thermodynamic reversibility from the database
# Line 1784  Line 2104 
2104                          $NewModelTable->add_row({"LOAD" => [$ReactionID],"DIRECTIONALITY" => [$Directionality],"COMPARTMENT" => ["c"],"ASSOCIATED PEG" => ["UNIVERSAL"],"SUBSYSTEM" => ["NONE"],"CONFIDENCE" => [4],"REFERENCE" => ["UNIVERSAL"],"NOTES" => ["NONE"]});                          $NewModelTable->add_row({"LOAD" => [$ReactionID],"DIRECTIONALITY" => [$Directionality],"COMPARTMENT" => ["c"],"ASSOCIATED PEG" => ["UNIVERSAL"],"SUBSYSTEM" => ["NONE"],"CONFIDENCE" => [4],"REFERENCE" => ["UNIVERSAL"],"NOTES" => ["NONE"]});
2105                  }                  }
2106          }          }
2107            #Creating biomass reaction for model
2108          #Checking if a biomass reaction already exists          my $biomassID = $self->BuildSpecificBiomassReaction();
2109          my $BiomassReactionRow = $self->BuildSpecificBiomassReaction();          if ($biomassID !~ m/bio\d\d\d\d\d/) {
2110          if (!defined($BiomassReactionRow)) {                  $self->set_status(-2,"Preliminary reconstruction failed: could not generate biomass reaction");
2111                  $self->set_status(-2,"Preliminary reconstruction failed: could not generate biomass reaction");                  die $self->error_message("CreateSingleGenomeReactionList: Could not generate biomass reaction!");
2112                  $self->figmodel()->error_message("FIGMODEL:CreateModelReactionList: Could not generate biomass function for ".$self->id()."!");          }
2113                  return $self->fail();          #Getting the biomass reaction PPO object
2114            my $bioRxn = $self->figmodel()->database()->get_object("bof",{id=>$biomassID});
2115            if (!defined($bioRxn)) {
2116                    die $self->error_message("CreateSingleGenomeReactionList: Could not find biomass reaction ".$biomassID."!");
2117            }
2118            #Getting the list of essential reactions for biomass reaction
2119            my $ReactionList;
2120            my $essentialReactions = $bioRxn->essentialRxn();
2121            if (defined($essentialReactions) && $essentialReactions =~ m/rxn\d\d\d\d\d/) {
2122                    push(@{$ReactionList},split(/\|/,$essentialReactions));
2123                    if ($essentialReactions !~ m/$biomassID/) {
2124                            push(@{$ReactionList},$biomassID);
2125                    }
2126          }          }
         my $ReactionList = $BiomassReactionRow->{"ESSENTIAL REACTIONS"};  
         push(@{$ReactionList},$BiomassReactionRow->{DATABASE}->[0]);  
   
2127          #Adding biomass reactions to the model table          #Adding biomass reactions to the model table
2128          foreach my $BOFReaction (@{$ReactionList}) {          foreach my $BOFReaction (@{$ReactionList}) {
2129                  #Getting the thermodynamic reversibility from the database                  #Getting the thermodynamic reversibility from the database
# Line 1808  Line 2137 
2137                          }                          }
2138                  }                  }
2139          }          }
   
2140          #Completing any incomplete reactions sets          #Completing any incomplete reactions sets
2141          my $ReactionSetTable = $self->figmodel()->database()->GetDBTable("REACTION SETS");          my $ReactionSetTable = $self->figmodel()->database()->GetDBTable("REACTION SETS");
2142          for (my $i=0; $i < $ReactionSetTable->size(); $i++) {          for (my $i=0; $i < $ReactionSetTable->size(); $i++) {
# Line 1822  Line 2150 
2150                          }                          }
2151                  }                  }
2152          }          }
2153            #If an original model exists, we copy the gap filling solution from that model
2154            if (defined($OriginalModelTable)) {
2155                    for (my $i=0; $i < $OriginalModelTable->size(); $i++) {
2156                            if ($OriginalModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] =~ m/GAP/ && $OriginalModelTable->get_row($i)->{"ASSOCIATED PEG"}->[0] ne "INITIAL GAP FILLING") {
2157                                    my $Row = $NewModelTable->get_row_by_key($OriginalModelTable->get_row($i)->{"LOAD"}->[0],"LOAD");
2158                                    if (!defined($Row)) {
2159                                            $NewModelTable->add_row($OriginalModelTable->get_row($i));
2160                                    }
2161                            }
2162                    }
2163            }
2164          #Now we compare the model to the previous model to determine if any differences exist that aren't gap filling reactions          #Now we compare the model to the previous model to determine if any differences exist that aren't gap filling reactions
2165          if (defined($OriginalModelTable)) {          if (defined($OriginalModelTable)) {
2166                  my $PerfectMatch = 1;                  my $PerfectMatch = 1;
# Line 1878  Line 2216 
2216                          return $self->success();                          return $self->success();
2217                  }                  }
2218          }          }
   
2219          #Saving the new model to file          #Saving the new model to file
2220          $self->set_status(1,"Preliminary reconstruction complete");          $self->set_status(1,"Preliminary reconstruction complete");
2221          $self->figmodel()->database()->save_table($NewModelTable);          $self->figmodel()->database()->save_table($NewModelTable);
2222          $self->{_reaction_data} = $NewModelTable;          $self->reaction_table(1);
         #Clearing the previous model from the cache  
         $self->figmodel()->database()->ClearDBModel($self->id(),1);  
2223          #Updating the model stats table          #Updating the model stats table
2224          $self->update_stats_for_build();          $self->update_stats_for_build();
2225          $self->PrintSBMLFile();          $self->PrintSBMLFile();
2226            $self->PrintModelLPFile();
2227            $self->PrintModelSimpleReactionTable();
2228            if (defined($OriginalModelTable)) {
2229                    $self->calculate_model_changes($OriginalModelTable,"REBUILD");
2230            }
2231          #Adding model to gapfilling queue          #Adding model to gapfilling queue
2232          if (defined($RunGapFilling) && $RunGapFilling == 1) {          if (defined($RunGapFilling) && $RunGapFilling == 1) {
2233                  $self->set_status(1,"Autocompletion queued");                  $self->set_status(1,"Autocompletion queued");
# Line 1906  Line 2245 
2245    
2246  sub CreateMetaGenomeReactionList {  sub CreateMetaGenomeReactionList {
2247          my ($self) = @_;          my ($self) = @_;
   
2248          #Checking if the metagenome file exists          #Checking if the metagenome file exists
2249          if (!-e $self->config("raw MGRAST directory")->[0].$self->genome().".summary") {          if (!-e $self->config("raw MGRAST directory")->[0].$self->genome().".summary") {
2250                  $self->error_message("FIGMODEL:CreateMetaGenomeReactionList: could not find raw data file for metagenome ".$self->genome());                  $self->error_message("FIGMODEL:CreateMetaGenomeReactionList: could not find raw data file for metagenome ".$self->genome());
2251                    return $self->fail();
2252          }          }
2253          #Loading metagenome data          #Loading metagenome data
2254          my $MGRASTData = $self->figmodel()->database()->load_multiple_column_file($self->config("raw MGRAST directory")->[0].$self->genome().".summary","\t");          my $MGRASTData = $self->figmodel()->database()->load_multiple_column_file($self->config("raw MGRAST directory")->[0].$self->genome().".summary","\t");
2255          if (!defined($MGRASTData)) {          if (!defined($MGRASTData)) {
2256                  $self->error_message("FIGMODEL:CreateMetaGenomeReactionList: could not find raw data file for metagenome ".$self->genome());                  $self->error_message("FIGMODEL:CreateMetaGenomeReactionList: could not find raw data file for metagenome ".$self->genome());
2257                    return $self->fail();
2258          }          }
   
2259          #Setting up needed variables          #Setting up needed variables
2260          my $OriginalModelTable = undef;          my $OriginalModelTable = undef;
   
2261          #Checking status          #Checking status
2262          if ($self->status() < 0) {          if ($self->status() < 0) {
2263                  $self->set_status(0,"Preliminary reconstruction");                  $self->set_status(0,"Preliminary reconstruction");
# Line 1931  Line 2269 
2269                  $self->ArchiveModel();                  $self->ArchiveModel();
2270                  $self->set_status(0,"Rebuilding preliminary reconstruction");                  $self->set_status(0,"Rebuilding preliminary reconstruction");
2271          }          }
2272            #Creating a hash of escores and pegs associated with each role
2273            my $rolePegHash;
2274            my $roleEscores;
2275            for (my $i=0; $i < @{$MGRASTData};$i++) {
2276                    #MD5,PEG,number of sims,role,sim e-scores,max escore,min escore,ave escore,stdev escore,ave exponent,stddev exponent
2277                    $rolePegHash->{$MGRASTData->[$i]->[3]}->{substr($MGRASTData->[$i]->[1],4)} = 1;
2278                    push(@{$roleEscores->{$MGRASTData->[$i]->[3]}},split(/;/,$MGRASTData->[$i]->[4]));
2279            }
2280          #Getting the reaction table          #Getting the reaction table
2281          my $ReactionTable = $self->figmodel()->database()->GetDBTable("REACTIONS");          my $ReactionTable = $self->figmodel()->database()->get_table("REACTIONS");
2282          #Creating model table          #Creating model table
2283          my $ModelTable = FIGMODELTable->new(["LOAD","DIRECTIONALITY","COMPARTMENT","ASSOCIATED PEG","SUBSYSTEM","CONFIDENCE","REFERENCE","NOTES"],$self->directory().$self->id().".txt",["LOAD"],";","|","REACTIONS\n");          my $ModelTable = $self->create_table_prototype("ModelReactions");
2284          for (my $i=0; $i < @{$MGRASTData};$i++) {          print $ModelTable->filename();
2285                  #MD5,PEG,number of sims,role,sim e-scores          my @roles = keys(%{$rolePegHash});
2286                  my $Role = $MGRASTData->[$i]->[3];          for (my $i=0; $i < @roles; $i++) {
2287                  my $MD5 = $MGRASTData->[$i]->[0];                  my $min = -1;
2288                  my $peg = $MGRASTData->[$i]->[1];                  my $max = -1;
2289                  my $sims = $MGRASTData->[$i]->[4];                  my $count = @{$roleEscores->{$roles[$i]}};
2290                  $sims =~ s/;/,/g;                  my $ave = 0;
2291                    my $stdev = 0;
2292                    my $aveexp = 0;
2293                    my $stdevexp = 0;
2294                    for (my $j=0; $j < @{$roleEscores->{$roles[$i]}}; $j++) {
2295                            if ($roleEscores->{$roles[$i]} < $min || $min == -1) {
2296                                    $min = $roleEscores->{$roles[$i]};
2297                            }
2298                            if ($roleEscores->{$roles[$i]} > $max || $max == -1) {
2299                                    $max = $roleEscores->{$roles[$i]};
2300                            }
2301                            $ave += $roleEscores->{$roles[$i]}->[$j];
2302                            if ($roleEscores->{$roles[$i]}->[$j] =~ m/e(-\d+$)/) {
2303                                    $aveexp += $1;
2304                            }
2305                    }
2306                    $ave = $ave/$count;
2307                    $aveexp = $aveexp/$count;
2308                    for (my $j=0; $j < @{$roleEscores->{$roles[$i]}}; $j++) {
2309                            $stdev += ($roleEscores->{$roles[$i]}->[$j]-$ave)*($roleEscores->{$roles[$i]}->[$j]-$ave);
2310                            if ($roleEscores->{$roles[$i]}->[$j] =~ m/e(-\d+$)/) {
2311                                    $stdevexp += ($1-$aveexp)*($1-$aveexp);
2312                            }
2313                    }
2314                    $stdev = sqrt($stdev/$count);
2315                    $stdevexp = sqrt($stdevexp/$count);
2316                  #Checking for subsystems                  #Checking for subsystems
2317                  my $GeneSubsystems = $self->figmodel()->subsystems_of_role($Role);                  my $GeneSubsystems = $self->figmodel()->subsystems_of_role($roles[$i]);
2318                  #Checking if there are reactions associated with this role                  #Checking if there are reactions associated with this role
2319                  my $ReactionHashArrayRef = $self->figmodel()->reactions_of_role($Role);                  my $ReactionHashArrayRef = $self->figmodel()->reactions_of_role($roles[$i]);
2320                  if ($ReactionHashArrayRef != 0) {                  if ($ReactionHashArrayRef != 0) {
2321                          foreach my $Mapping (@{$ReactionHashArrayRef}) {                          foreach my $Mapping (@{$ReactionHashArrayRef}) {
2322                                  if (defined($Mapping->{"REACTION"}) && defined($Mapping->{"MASTER"}) && defined($Mapping->{"SUBSYSTEM"}) && defined($Mapping->{"SOURCE"})) {                                  if (defined($Mapping->{"REACTION"}) && defined($Mapping->{"MASTER"}) && defined($Mapping->{"SUBSYSTEM"}) && defined($Mapping->{"SOURCE"})) {
# Line 1959  Line 2328 
2328                                                                  $ReactionRow = {"LOAD" => [$Mapping->{"REACTION"}->[0]],"DIRECTIONALITY" => [$self->figmodel()->reversibility_of_reaction($Mapping->{"REACTION"}->[0])],"COMPARTMENT" => ["c"]};                                                                  $ReactionRow = {"LOAD" => [$Mapping->{"REACTION"}->[0]],"DIRECTIONALITY" => [$self->figmodel()->reversibility_of_reaction($Mapping->{"REACTION"}->[0])],"COMPARTMENT" => ["c"]};
2329                                                                  $ModelTable->add_row($ReactionRow);                                                                  $ModelTable->add_row($ReactionRow);
2330                                                          }                                                          }
2331                                                          push(@{$ReactionRow->{"ASSOCIATED PEG"}},substr($peg,4));                                                          my %pegHash = %{$rolePegHash->{$roles[$i]}};
2332                                                          push(@{$ReactionRow->{"REFERENCE"}},$MD5.":".$Role);                                                          if (defined($ReactionRow->{"ASSOCIATED PEG"})) {
2333                                                          push(@{$ReactionRow->{"CONFIDENCE"}},$sims);                                                                  for (my $j=0; $j < @{$ReactionRow->{"ASSOCIATED PEG"}}; $j++) {
2334                                                                            $pegHash{$ReactionRow->{"ASSOCIATED PEG"}->[$j]} = 1;
2335                                                                    }
2336                                                            }
2337                                                            delete $ReactionRow->{"ASSOCIATED PEG"};
2338                                                            push(@{$ReactionRow->{"ASSOCIATED PEG"}},keys(%pegHash));
2339                                                            push(@{$ReactionRow->{"REFERENCE"}},$count.":".$ave.":".$stdev.":".$aveexp.":".$stdevexp.":".$min.":".$max);
2340                                                          if (defined($GeneSubsystems)) {                                                          if (defined($GeneSubsystems)) {
2341                                                                  push(@{$ReactionRow->{"SUBSYSTEM"}},@{$GeneSubsystems});                                                                  push(@{$ReactionRow->{"SUBSYSTEM"}},@{$GeneSubsystems});
2342                                                          }                                                          }
# Line 2387  Line 2762 
2762          Calculating growth in the input media          Calculating growth in the input media
2763  =cut  =cut
2764  sub calculate_growth {  sub calculate_growth {
2765          my ($self,$Media) = @_;          my ($self,$Media,$outputDirectory,$InParameters,$saveLPFile) = @_;
2766            #Setting the Media
2767            if (!defined($Media) || length($Media) == 0) {
2768                    $Media = $self->autocompleteMedia();
2769            }
2770            #Setting parameters for the run
2771            my $DefaultParameters = $self->figmodel()->defaultParameters();
2772            if (defined($InParameters)) {
2773                    my @parameters = keys(%{$InParameters});
2774                    for (my $i=0; $i < @parameters; $i++) {
2775                            $DefaultParameters->{$parameters[$i]} = $InParameters->{$parameters[$i]};
2776                    }
2777            }
2778            $DefaultParameters->{"optimize metabolite production if objective is zero"} = 1;
2779            #Setting filenames
2780          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
2781          system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$Media,["ProductionMFA"],{"optimize metabolite production if objective is zero" => 1},$self->id()."-".$Media."-GrowthTest.txt",undef,$self->selected_version()));          if (!defined($outputDirectory)) {
2782                    $outputDirectory = $self->config("database message file directory")->[0];
2783            }
2784            my $fluxFilename = $outputDirectory."Fluxes-".$self->id()."-".$Media.".txt";
2785            my $cpdFluxFilename = $outputDirectory."CompoundFluxes-".$self->id()."-".$Media.".txt";
2786            #Running FBA
2787            #print $self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$Media,["ProductionMFA"],$DefaultParameters,$self->id()."-".$Media."-GrowthTest.txt",undef,$self->selected_version())."\n";
2788            system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$Media,["ProductionMFA"],$DefaultParameters,$self->id()."-".$Media."-GrowthTest.txt",undef,$self->selected_version()));
2789            #Saving LP file if requested
2790            if (defined($saveLPFile) && $saveLPFile == 1 && -e $self->figmodel()->{"MFAToolkit output directory"}->[0].$UniqueFilename."/CurrentProblem.lp") {
2791                    system("cp ".$self->figmodel()->config("MFAToolkit output directory")->[0].$UniqueFilename."/CurrentProblem.lp ".$self->directory().$self->id().".lp");
2792            }
2793          my $ProblemReport = $self->figmodel()->LoadProblemReport($UniqueFilename);          my $ProblemReport = $self->figmodel()->LoadProblemReport($UniqueFilename);
2794          my $Result;          my $Result;
2795          if (defined($ProblemReport)) {          if (defined($ProblemReport)) {
2796                  my $Row = $ProblemReport->get_row(0);                  my $Row = $ProblemReport->get_row(0);
2797                  if (defined($Row) && defined($Row->{"Objective"}->[0])) {                  if (defined($Row) && defined($Row->{"Objective"}->[0])) {
2798                          if ($Row->{"Objective"}->[0] < 0.00000001) {                          if ($Row->{"Objective"}->[0] < 0.00000001 || $Row->{"Objective"}->[0] == 1e7) {
2799                                  $Result = "NOGROWTH:".$Row->{"Individual metabolites with zero production"}->[0];                                  $Result = "NOGROWTH";
2800                          } else {                                  if (defined($Row->{"Individual metabolites with zero production"}->[0]) && $Row->{"Individual metabolites with zero production"}->[0] =~ m/cpd\d\d\d\d\d/) {
2801                                            $Result .= ":".$Row->{"Individual metabolites with zero production"}->[0];
2802                                    }
2803                                    $self->growth(0);
2804                                    $self->noGrowthCompounds($Row->{"Individual metabolites with zero production"}->[0]);
2805                            } else {
2806                                    if (-e $self->figmodel()->config("MFAToolkit output directory")->[0].$UniqueFilename."/MFAOutput/SolutionReactionData0.txt") {
2807                                            system("cp ".$self->figmodel()->config("MFAToolkit output directory")->[0].$UniqueFilename."/MFAOutput/SolutionReactionData0.txt ".$fluxFilename);
2808                                            system("cp ".$self->figmodel()->config("MFAToolkit output directory")->[0].$UniqueFilename."/MFAOutput/SolutionCompoundData0.txt ".$cpdFluxFilename);
2809                                    }
2810                                  $Result = $Row->{"Objective"}->[0];                                  $Result = $Row->{"Objective"}->[0];
2811                                    $self->growth($Result);
2812                                    $self->noGrowthCompounds("NONE");
2813                            }
2814                          }                          }
2815                  }                  }
2816            #Deleting files if necessary
2817            if ($self->figmodel()->config("preserve all log files")->[0] ne "yes") {
2818                    $self->figmodel()->cleardirectory($UniqueFilename);
2819                    unlink($self->figmodel()->config("database message file directory")->[0].$self->id()."-".$Media."-GrowthTest.txt");
2820          }          }
2821            #Returning result
2822          return $Result;          return $Result;
2823  }  }
2824    
# Line 3413  Line 3830 
3830          return 1;          return 1;
3831  }  }
3832    
3833  =head3 BuildSpecificBiomassReaction  =head3 DetermineCofactorLipidCellWallComponents
3834  Definition:  Definition:
3835          FIGMODELmodel->BuildSpecificBiomassReaction();          {cofactor=>{string:compound id=>float:coefficient},lipid=>...cellWall=>} = FIGMODELmodel->DetermineCofactorLipidCellWallComponents();
3836  Description:  Description:
3837  =cut  =cut
3838  sub BuildSpecificBiomassReaction {  sub DetermineCofactorLipidCellWallComponents {
3839          my ($self) = @_;          my ($self) = @_;
3840            my $templateResults;
         my $biomassrxn;  
         my $OrganismID = $self->genome();  
         #Checking for a biomass override  
         if (defined($self->config("biomass reaction override")->{$OrganismID})) {  
                 my $biomassID = $self->config("biomass reaction override")->{$OrganismID};  
                 my $tbl = $self->database()->get_table("BIOMASS",1);  
                 $biomassrxn = $tbl->get_row_by_key($biomassID,"DATABASE");  
                 print "Overriding biomass template and selecting ".$biomassID." for ".$OrganismID.".\n";  
         } else {#Creating biomass reaction from the template  
                 #Getting the genome stats  
3841                  my $genomestats = $self->figmodel()->get_genome_stats($self->genome());                  my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
3842                  my $Class = $genomestats->{CLASS}->[0];          my $Class = $self->{_data}->cellwalltype();
3843                  my $Name = $genomestats->{NAME}->[0];          my $Name = $self->name();
3844            my $translation = {COFACTOR=>"cofactor",LIPIDS=>"lipid","CELL WALL"=>"cellWall"};
3845                  #Checking for phoenix variants                  #Checking for phoenix variants
3846                  my $PhoenixVariantTable = $self->figmodel()->database()->GetDBTable("Phoenix variants table");                  my $PhoenixVariantTable = $self->figmodel()->database()->GetDBTable("Phoenix variants table");
3847                  my $Phoenix = 0;                  my $Phoenix = 0;
3848                  my @Rows = $PhoenixVariantTable->get_rows_by_key($OrganismID,"GENOME");          my @Rows = $PhoenixVariantTable->get_rows_by_key($self->genome(),"GENOME");
3849                  my $VariantHash;                  my $VariantHash;
3850                  for (my $i=0; $i < @Rows; $i++) {                  for (my $i=0; $i < @Rows; $i++) {
3851                          $Phoenix = 1;                          $Phoenix = 1;
# Line 3446  Line 3853 
3853                                  $VariantHash->{$Rows[$i]->{"SUBSYSTEM"}->[0]} = $Rows[$i]->{"VARIANT"}->[0];                                  $VariantHash->{$Rows[$i]->{"SUBSYSTEM"}->[0]} = $Rows[$i]->{"VARIANT"}->[0];
3854                          }                          }
3855                  }                  }
   
3856                  #Collecting genome data                  #Collecting genome data
3857                  my $RoleHash;                  my $RoleHash;
3858                  my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());                  my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
# Line 3463  Line 3869 
3869                                  }                                  }
3870                          }                          }
3871                  }                  }
   
3872                  #Scanning through the template item by item and determinine which biomass components should be added                  #Scanning through the template item by item and determinine which biomass components should be added
3873                  my $ComponentTypes;          my $includedHash;
3874                  my $EquationData;          my $BiomassReactionTemplateTable = $self->figmodel()->database()->get_table("BIOMASSTEMPLATE");
                 my $BiomassReactionTemplateTable = $self->figmodel()->database()->GetDBTable("BIOMASS TEMPLATE");  
3875                  for (my $i=0; $i < $BiomassReactionTemplateTable->size(); $i++) {                  for (my $i=0; $i < $BiomassReactionTemplateTable->size(); $i++) {
3876                          my $Row = $BiomassReactionTemplateTable->get_row($i);                          my $Row = $BiomassReactionTemplateTable->get_row($i);
3877                    if (defined($translation->{$Row->{CLASS}->[0]})) {
3878                            my $coef = -1;
3879                            if ($Row->{"REACTANT"}->[0] eq "NO") {
3880                                    $coef = 1;
3881                                    if ($Row->{"COEFFICIENT"}->[0] =~ m/cpd/) {
3882                                            $coef = $Row->{"COEFFICIENT"}->[0];
3883                                    }
3884                            }
3885                          if (defined($Row->{"INCLUSION CRITERIA"}->[0]) && $Row->{"INCLUSION CRITERIA"}->[0] eq "UNIVERSAL") {                          if (defined($Row->{"INCLUSION CRITERIA"}->[0]) && $Row->{"INCLUSION CRITERIA"}->[0] eq "UNIVERSAL") {
3886                                  push(@{$EquationData},$Row);                                  $includedHash->{$Row->{"ID"}->[0]} = 1;
3887                                  $ComponentTypes->{$Row->{"CLASS"}->[0]}->{$Row->{"ID"}->[0]} = 1;                                  $templateResults->{$translation->{$Row->{CLASS}->[0]}}->{$Row->{"ID"}->[0]} = $coef;
3888                          } else {                          } elsif (defined($Row->{"INCLUSION CRITERIA"}->[0])) {
3889                                  my $Criteria = $Row->{"INCLUSION CRITERIA"}->[0];                                  my $Criteria = $Row->{"INCLUSION CRITERIA"}->[0];
3890                                  my $End = 0;                                  my $End = 0;
3891                                  while ($End == 0) {                                  while ($End == 0) {
3892                                          if ($Criteria =~ m/^(.+)(AND)\{([^{^}]+)\}(.+)$/ || $Criteria =~ m/^(AND)\{([^{^}]+)\}$/ || $Criteria =~ m/^(.+)(OR)\{([^{^}]+)\}(.+)$/ || $Criteria =~ m/^(OR)\{([^{^}]+)\}$/) {                                          if ($Criteria =~ m/^(.+)(AND)\{([^{^}]+)\}(.+)$/ || $Criteria =~ m/^(AND)\{([^{^}]+)\}$/ || $Criteria =~ m/^(.+)(OR)\{([^{^}]+)\}(.+)$/ || $Criteria =~ m/^(OR)\{([^{^}]+)\}$/) {
3893                                                  print $Criteria."\n";                                                  print $Criteria." : ";
3894                                                  my $Start = "";                                                  my $Start = "";
3895                                                  my $End = "";                                                  my $End = "";
3896                                                  my $Condition = $1;                                                  my $Condition = $1;
# Line 3502  Line 3914 
3914                                                                  $Result = "NO";                                                                  $Result = "NO";
3915                                                                  last;                                                                  last;
3916                                                          } elsif ($Array[$j] =~ m/^COMPOUND:(.+)/) {                                                          } elsif ($Array[$j] =~ m/^COMPOUND:(.+)/) {
3917                                                                  my $Match = 0;                                                                  if (defined($includedHash->{$1}) && $Condition eq "OR") {
                                                                 for (my $k=0; $k < @{$EquationData}; $k++) {  
                                                                         if ($EquationData->[$k]->{"ID"}->[0] eq $1) {  
                                                                                 $Match = 1;  
                                                                                 last;  
                                                                         }  
                                                                 }  
                                                                 if ($Match == 1 && $Condition eq "OR") {  
3918                                                                          $Result = "YES";                                                                          $Result = "YES";
3919                                                                          last;                                                                          last;
3920                                                                  } elsif ($Match != 1 && $Condition eq "AND") {                                                                  } elsif (!defined($includedHash->{$1}) && $Condition eq "AND") {
3921                                                                          $Result = "NO";                                                                          $Result = "NO";
3922                                                                          last;                                                                          last;
3923                                                                  }                                                                  }
3924                                                          } elsif ($Array[$j] =~ m/^!COMPOUND:(.+)/) {                                                          } elsif ($Array[$j] =~ m/^!COMPOUND:(.+)/) {
3925                                                                  my $Match = 0;                                                                  if (!defined($includedHash->{$1}) && $Condition eq "OR") {
                                                                 for (my $k=0; $k < @{$EquationData}; $k++) {  
                                                                         if ($EquationData->[$k]->{"ID"}->[0] eq $1) {  
                                                                                 $Match = 1;  
                                                                                 last;  
                                                                         }  
                                                                 }  
                                                                 if ($Match != 1 && $Condition eq "OR") {  
3926                                                                          $Result = "YES";                                                                          $Result = "YES";
3927                                                                          last;                                                                          last;
3928                                                                  } elsif ($Match == 1 && $Condition eq "AND") {                                                                  } elsif (defined($includedHash->{$1}) && $Condition eq "AND") {
3929                                                                          $Result = "NO";                                                                          $Result = "NO";
3930                                                                          last;                                                                          last;
3931                                                                  }                                                                  }
# Line 3643  Line 4041 
4041                                          }                                          }
4042                                  }                                  }
4043                                  if ($Criteria eq "YES") {                                  if ($Criteria eq "YES") {
4044                                          push(@{$EquationData},$Row);                                          $templateResults->{$translation->{$Row->{CLASS}->[0]}}->{$Row->{"ID"}->[0]} = $coef;
4045                                          $ComponentTypes->{$Row->{"CLASS"}->[0]}->{$Row->{"ID"}->[0]} = 1;                                          $includedHash->{$Row->{"ID"}->[0]} = 1;
4046                                  }                                  }
4047                          }                          }
4048                  }                  }
4049            }
4050                  #Building biomass equation          my $types = ["cofactor","lipid","cellWall"];
4051                  my %Reactants;          my $cpdMgr = $self->figmodel()->database()->get_object_manager("compound");
4052                  my %Products;          for (my $i=0; $i < @{$types}; $i++) {
4053                  foreach my $EquationRow (@{$EquationData}) {                  my @list =      keys(%{$templateResults->{$types->[$i]}});
4054                          #First determine what the coefficient should be                  my $entries = 0;
4055                          my $Coefficient;                  for (my $j=0; $j < @list; $j++) {
4056                          if (defined($EquationRow->{"COEFFICIENT"}) && $EquationRow->{"COEFFICIENT"}->[0] =~ m/^[0-9\.]+$/) {                          if ($templateResults->{$types->[$i]}->{$list[$j]} eq "-1") {
4057                                  $Coefficient = $EquationRow->{"COEFFICIENT"}->[0];                                  my $objs = $cpdMgr->get_objects({id=>$list[$j]});
4058                          } elsif (defined($EquationRow->{"COEFFICIENT"}) && $EquationRow->{"COEFFICIENT"}->[0] =~ m/cpd\d\d\d\d\d/) {                                  if (!defined($objs->[0]) || $objs->[0]->mass() == 0) {
4059                                  $Coefficient = 0;                                          $templateResults->{$types->[$i]}->{$list[$j]} = -1e-5;
                                 my @CompoundList = split(/,/,$EquationRow->{"COEFFICIENT"}->[0]);  
                                 foreach my $Compound (@CompoundList) {  
                                         if (defined($Reactants{$Compound})) {  
                                                 $Coefficient += $Reactants{$Compound};  
                                         }  
                                 }  
                         } elsif (defined($EquationRow->{"COEFFICIENT"}) && $EquationRow->{"COEFFICIENT"}->[0] =~ m/^([0-9\.]+)\/(.+)$/) {  
                                 my @Keys = keys(%{$ComponentTypes->{$2}});  
                                 my $MW = 1;  
                                 my $CompoundData = $self->figmodel()->LoadObject($EquationRow->{"ID"}->[0]);  
                                 if (defined($CompoundData->{"MASS"})) {  
                                         $MW = $CompoundData->{"MASS"}->[0];  
                                 }  
                                 $Coefficient = $1/@Keys/$MW;  
                         }  
                         if (defined($EquationRow->{"REACTANT"}) && $EquationRow->{"REACTANT"}->[0] eq "YES") {  
                                 if (defined($Reactants{$EquationRow->{"ID"}->[0]})) {  
                                         $Reactants{$EquationRow->{"ID"}->[0]} += $Coefficient;  
                                 } elsif (defined($Products{$EquationRow->{"ID"}->[0]}) && $Products{$EquationRow->{"ID"}->[0]} > $Coefficient) {  
                                         $Products{$EquationRow->{"ID"}->[0]} -= $Coefficient;  
                                 } elsif (defined($Products{$EquationRow->{"ID"}->[0]}) && $Products{$EquationRow->{"ID"}->[0]} < $Coefficient) {  
                                         $Reactants{$EquationRow->{"ID"}->[0]} = $Coefficient - $Products{$EquationRow->{"ID"}->[0]};  
                                         delete $Products{$EquationRow->{"ID"}->[0]};  
                                 } else {  
                                         $Reactants{$EquationRow->{"ID"}->[0]} = $Coefficient;  
                                 }  
                         } else {  
                                 if (defined($Products{$EquationRow->{"ID"}->[0]})) {  
                                         $Products{$EquationRow->{"ID"}->[0]} += $Coefficient;  
                                 } elsif (defined($Reactants{$EquationRow->{"ID"}->[0]}) && $Reactants{$EquationRow->{"ID"}->[0]} > $Coefficient) {  
                                         $Reactants{$EquationRow->{"ID"}->[0]} -= $Coefficient;  
                                 } elsif (defined($Reactants{$EquationRow->{"ID"}->[0]}) && $Reactants{$EquationRow->{"ID"}->[0]} < $Coefficient) {  
                                         $Products{$EquationRow->{"ID"}->[0]} = $Coefficient - $Reactants{$EquationRow->{"ID"}->[0]};  
                                         delete $Reactants{$EquationRow->{"ID"}->[0]};  
4060                                  } else {                                  } else {
4061                                          $Products{$EquationRow->{"ID"}->[0]} = $Coefficient;                                          $entries++;
4062                                    }
4063                            }
4064                    }
4065                    for (my $j=0; $j < @list; $j++) {
4066                            if ($templateResults->{$types->[$i]}->{$list[$j]} eq "-1") {
4067                                    $templateResults->{$types->[$i]}->{$list[$j]} = -1/$entries;
4068                            } elsif ($templateResults->{$types->[$i]}->{$list[$j]} =~ m/cpd/) {
4069                                    my $netCoef = 0;
4070                                    my @allcpd = split(/,/,$templateResults->{$types->[$i]}->{$list[$j]});
4071                                    for (my $k=0; $k < @allcpd; $k++) {
4072                                            if (defined($templateResults->{$types->[$i]}->{$allcpd[$k]}) && $templateResults->{$types->[$i]}->{$allcpd[$k]} ne "-1e-5") {
4073                                                    $netCoef += (1/$entries);
4074                                            } elsif (defined($templateResults->{$types->[$i]}->{$allcpd[$k]}) && $templateResults->{$types->[$i]}->{$allcpd[$k]} eq "-1e-5") {
4075                                                    $netCoef += 1e-5;
4076                                            }
4077                                    }
4078                                    $templateResults->{$types->[$i]}->{$list[$j]} = $netCoef;
4079                            }
4080                                  }                                  }
4081                          }                          }
4082            return $templateResults;
4083                  }                  }
4084    
4085    =head3 BuildSpecificBiomassReaction
4086    Definition:
4087            FIGMODELmodel->BuildSpecificBiomassReaction();
4088    Description:
4089    =cut
4090    sub BuildSpecificBiomassReaction {
4091            my ($self) = @_;
4092            #Getting the database handle for biomass reactions
4093            my $bioMgr = $self->figmodel()->database()->get_object_manager("bof");
4094            #Checking if the current biomass reaction appears in more than on model, if not, this biomass reaction is conserved for this model
4095            my $biomassID = $self->biomassReaction();
4096            if ($biomassID =~ m/bio\d\d\d\d\d/) {
4097                    my $mdlMgr = $self->figmodel()->database()->get_object_manager("model");
4098                    my $mdlObs = $mdlMgr->get_objects({biomassReaction=>$biomassID});
4099                    if (defined($mdlObs->[1])) {
4100                            $biomassID = "NONE";
4101                    }
4102            }
4103            #If the biomass ID is "NONE", then we create a new biomass reaction for the model
4104            my $bioObj;
4105            my $originalPackages = "";
4106            my $originalEssReactions = "";
4107            if ($biomassID !~ m/bio\d\d\d\d\d/) {
4108                    #Getting the current largest ID
4109                    $biomassID = $self->figmodel()->database()->check_out_new_id("bof");
4110                    $bioObj = $bioMgr->create({
4111                            id=>$biomassID,owner=>$self->owner(),users=>$self->users(),name=>"Biomass",equation=>"NONE",protein=>"0",
4112                            energy=>"0",DNA=>"0",RNA=>"0",lipid=>"0",cellWall=>"0",cofactor=>"0",
4113                            modificationDate=>time(),creationDate=>time(),
4114                            cofactorPackage=>"NONE",lipidPackage=>"NONE",cellWallPackage=>"NONE",
4115                            DNACoef=>"NONE",RNACoef=>"NONE",proteinCoef=>"NONE",lipidCoef=>"NONE",
4116                            cellWallCoef=>"NONE",cofactorCoef=>"NONE",essentialRxn=>"NONE"});
4117                    if (!defined($bioObj)) {
4118                            die $self->error_message("BuildSpecificBiomassReaction():Could not create new biomass reaction ".$biomassID."!");
4119                    }
4120            } else {
4121                    #Getting the biomass DB handler from the database
4122                    my $objs = $bioMgr->get_objects({id=>$biomassID});
4123                    if (!defined($objs->[0])) {
4124                            die $self->error_message("BuildSpecificBiomassReaction():Could not find biomass reaction ".$biomassID." in database!");
4125                    }
4126                    $bioObj = $objs->[0];
4127                    $bioObj->owner($self->owner());
4128                    $bioObj->users($self->users());
4129                    if (defined($bioObj->essentialRxn())) {
4130                            $originalEssReactions = $bioObj->essentialRxn();
4131                            $originalPackages = $bioObj->cofactorPackage().$bioObj->lipidPackage().$bioObj->cellWallPackage();
4132                    }
4133            }
4134            #Getting genome stats
4135            my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
4136            my $Class = $self->{_data}->cellwalltype();
4137            #Setting global coefficients based on cell wall type
4138            my $biomassCompounds;
4139            my $compounds;
4140            if ($Class eq "Gram positive") {
4141                    $compounds->{RNA} = {cpd00002=>-0.262,cpd00012=>1,cpd00038=>-0.323,cpd00052=>-0.199,cpd00062=>-0.215};
4142                    $compounds->{protein} = {cpd00001=>1,cpd00023=>-0.0637,cpd00033=>-0.0999,cpd00035=>-0.0653,cpd00039=>-0.0790,cpd00041=>-0.0362,cpd00051=>-0.0472,cpd00053=>-0.0637,cpd00054=>-0.0529,cpd00060=>-0.0277,cpd00065=>-0.0133,cpd00066=>-0.0430,cpd00069=>-0.0271,cpd00084=>-0.0139,cpd00107=>-0.0848,cpd00119=>-0.0200,cpd00129=>-0.0393,cpd00132=>-0.0362,cpd00156=>-0.0751,cpd00161=>-0.0456,cpd00322=>-0.0660};
4143                    $bioObj->protein("0.5284");
4144                    $bioObj->DNA("0.026");
4145                    $bioObj->RNA("0.0655");
4146                    $bioObj->lipid("0.075");
4147                    $bioObj->cellWall("0.25");
4148                    $bioObj->cofactor("0.10");
4149            } else {
4150                    $compounds->{RNA} = {cpd00002=>-0.262,cpd00012=>1,cpd00038=>-0.322,cpd00052=>-0.2,cpd00062=>-0.216};
4151                    $compounds->{protein} = {cpd00001=>1,cpd00023=>-0.0492,cpd00033=>-0.1145,cpd00035=>-0.0961,cpd00039=>-0.0641,cpd00041=>-0.0451,cpd00051=>-0.0554,cpd00053=>-0.0492,cpd00054=>-0.0403,cpd00060=>-0.0287,cpd00065=>-0.0106,cpd00066=>-0.0347,cpd00069=>-0.0258,cpd00084=>-0.0171,cpd00107=>-0.0843,cpd00119=>-0.0178,cpd00129=>-0.0414,cpd00132=>-0.0451,cpd00156=>-0.0791,cpd00161=>-0.0474,cpd00322=>-0.0543};
4152                    $bioObj->protein("0.563");
4153                    $bioObj->DNA("0.031");
4154                    $bioObj->RNA("0.21");
4155                    $bioObj->lipid("0.093");
4156                    $bioObj->cellWall("0.177");
4157                    $bioObj->cofactor("0.039");
4158            }
4159            #Setting energy coefficient for all reactions
4160            $bioObj->energy("40");
4161            $compounds->{energy} = {cpd00002=>-1,cpd00001=>-1,cpd00008=>1,cpd00009=>1,cpd00067=>1};
4162            #Setting DNA coefficients based on GC content
4163            my $gc = $self->figmodel()->get_genome_gc_content($self->genome());
4164            $compounds->{DNA} = {cpd00012=>1,cpd00115=>0.5*(1-$gc),cpd00241=>0.5*$gc,cpd00356=>0.5*$gc,cpd00357=>0.5*(1-$gc)};
4165            #Setting Lipid,cell wall,and cofactor coefficients based on biomass template
4166            my $templateResults = $self->DetermineCofactorLipidCellWallComponents();
4167            $compounds->{cofactor} = $templateResults->{cofactor};
4168            $compounds->{lipid} = $templateResults->{lipid};
4169            $compounds->{cellWall} = $templateResults->{cellWall};
4170            #Getting package number for cofactor, lipid, and cell wall
4171            my $packages;
4172            my $cpdgrpMgr = $self->figmodel()->database()->get_object_manager("cpdgrp");
4173            my $packageTypes = ["Cofactor","Lipid","CellWall"];
4174            my $translation = {"Cofactor"=>"cofactor","Lipid"=>"lipid","CellWall"=>"cellWall"};
4175            for (my $i=0; $i < @{$packageTypes}; $i++) {
4176                    my @cpdList = keys(%{$compounds->{$translation->{$packageTypes->[$i]}}});
4177                    my $function = $translation->{$packageTypes->[$i]}."Package";
4178                    if (@cpdList == 0) {
4179                            $bioObj->$function("NONE");
4180                    } else {
4181                            my $cpdgrpObs = $cpdgrpMgr->get_objects({type=>$packageTypes->[$i]."Package"});
4182                            for (my $j=0; $j < @{$cpdgrpObs}; $j++) {
4183                                    $packages->{$packageTypes->[$i]}->{$cpdgrpObs->[$j]->grouping()}->{$cpdgrpObs->[$j]->COMPOUND()} = 1;
4184                            }
4185                            my @packageList = keys(%{$packages->{$packageTypes->[$i]}});
4186                            my $packageHash;
4187                            for (my $j=0; $j < @packageList; $j++) {
4188                                    $packageHash->{join("|",sort(keys(%{$packages->{$packageTypes->[$i]}->{$packageList[$j]}})))} = $packageList[$j];
4189                            }
4190                            if (defined($packageHash->{join("|",sort(keys(%{$compounds->{$translation->{$packageTypes->[$i]}}})))})) {
4191                                    $bioObj->$function($packageHash->{join("|",sort(keys(%{$compounds->{$translation->{$packageTypes->[$i]}}})))});
4192                            } else {
4193                                    my $newPackageID = $self->figmodel()->database()->check_out_new_id($packageTypes->[$i]."Pkg");
4194                                    $bioObj->$function($newPackageID);
4195                                    my @cpdList = keys(%{$compounds->{$translation->{$packageTypes->[$i]}}});
4196                                    for (my $j=0; $j < @cpdList; $j++) {
4197                                            $cpdgrpMgr = $self->figmodel()->database()->get_object_manager("cpdgrp");
4198                                            $cpdgrpMgr->create({COMPOUND=>$cpdList[$j],grouping=>$newPackageID,type=>$packageTypes->[$i]."Package"});
4199                                    }
4200                            }
4201                    }
4202            }
4203            #Filling in coefficient terms in database and calculating global reaction coefficients based on classification abundancies
4204            my $equationCompounds;
4205            my $types = ["RNA","DNA","protein","lipid","cellWall","cofactor","energy"];
4206            my $cpdMgr = $self->figmodel()->database()->get_object_manager("compound");
4207            for (my $i=0; $i < @{$types}; $i++) {
4208                    my $coefString = "";
4209                    my @compounds = sort(keys(%{$compounds->{$types->[$i]}}));
4210                    #Building coefficient strings and determining net mass for component types
4211                    my $netMass = 0;
4212                    for (my $j=0; $j < @compounds; $j++) {
4213                            my $objs = $cpdMgr->get_objects({id=>$compounds[$j]});
4214                            my $mass = 0;
4215                            if (defined($objs->[0]) && $objs->[0]->mass() != 0) {
4216                                    $mass = $objs->[0]->mass();
4217                                    $netMass += -$compounds->{$types->[$i]}->{$compounds[$j]}*$objs->[0]->mass();
4218                            }
4219                            if (!defined($equationCompounds->{$compounds[$j]})) {
4220                                    $equationCompounds->{$compounds[$j]}->{"coef"} = 0;
4221                                    $equationCompounds->{$compounds[$j]}->{"type"} = $types->[$i];
4222                                    $equationCompounds->{$compounds[$j]}->{"mass"} = $mass;
4223                            }
4224                            $coefString .= $compounds->{$types->[$i]}->{$compounds[$j]}."|";
4225                    }
4226                    $netMass = 0.001*$netMass;
4227                    #Calculating coefficients for all component compounds
4228                    for (my $j=0; $j < @compounds; $j++) {
4229                            #Normalizing certain type coefficients by mass
4230                            my $function = $types->[$i];
4231                            my $fraction = $bioObj->$function();
4232                            if ($types->[$i] ne "energy") {
4233                                    $fraction = $fraction/$netMass;
4234                            }
4235                            if ($compounds->{$types->[$i]}->{$compounds[$j]} eq 1e-5) {
4236                                    $fraction = 1;
4237                            }
4238                            $equationCompounds->{$compounds[$j]}->{"coef"} += $fraction*$compounds->{$types->[$i]}->{$compounds[$j]};
4239                    }
4240                    chop($coefString);
4241                    if (length($coefString) == 0) {
4242                            $coefString = "NONE";
4243                    }
4244                    my $function = $types->[$i]."Coef";
4245                    if ($types->[$i] ne "energy") {
4246                            $bioObj->$function($coefString);
4247                    }
4248            }
4249            #Adding biomass to compound list
4250            $equationCompounds->{cpd17041}->{coef} = -1;
4251            $equationCompounds->{cpd17041}->{type} = "macromolecule";
4252            $equationCompounds->{cpd17042}->{coef} = -1;
4253            $equationCompounds->{cpd17042}->{type} = "macromolecule";
4254            $equationCompounds->{cpd17043}->{coef} = -1;
4255            $equationCompounds->{cpd17043}->{type} = "macromolecule";
4256            $equationCompounds->{cpd11416}->{coef} = 1;
4257            $equationCompounds->{cpd11416}->{type} = "macromolecule";
4258            #Building equation from hash and populating compound biomass table
4259            my @compoundList = keys(%{$equationCompounds});
4260            my ($reactants,$products);
4261            #Deleting existing Biomass Compound info
4262            my $cpdbofMgr = $self->figmodel()->database()->get_object_manager("cpdbof");
4263            my $matchingObjs = $cpdbofMgr->get_objects({BIOMASS=>$biomassID});
4264            for (my $i=0; $i < @{$matchingObjs}; $i++) {
4265                    $matchingObjs->[$i]->delete();
4266            }
4267            my $typeCategories = {"macromolecule"=>"M","RNA"=>"R","DNA"=>"D","protein"=>"P","lipid"=>"L","cellWall"=>"W","cofactor"=>"C","energy"=>"E"};
4268            my $productmass = 0;
4269            my $reactantmass = 0;
4270            my $totalmass = 0;
4271            foreach my $compound (@compoundList) {
4272                    if (defined($equationCompounds->{$compound}->{coef}) && defined($equationCompounds->{$compound}->{mass})) {
4273                            $totalmass += $equationCompounds->{$compound}->{coef}*0.001*$equationCompounds->{$compound}->{mass};
4274                    }
4275                    if ($equationCompounds->{$compound}->{coef} < 0) {
4276                            if (defined($equationCompounds->{$compound}->{coef}) && defined($equationCompounds->{$compound}->{mass})) {
4277                                    $reactantmass += $equationCompounds->{$compound}->{coef}*0.001*$equationCompounds->{$compound}->{mass};
4278                            }
4279                            $reactants->{$compound} = $self->figmodel()->format_coefficient(-1*$equationCompounds->{$compound}->{coef});
4280                    } else {
4281                            if (defined($equationCompounds->{$compound}->{coef}) && defined($equationCompounds->{$compound}->{mass})) {
4282                                    $productmass += $equationCompounds->{$compound}->{coef}*0.001*$equationCompounds->{$compound}->{mass};
4283                            }
4284                            $products->{$compound} = $self->figmodel()->format_coefficient($equationCompounds->{$compound}->{coef});
4285                    }
4286                    #Adding biomass reaction compounds to the biomass compound table
4287                    $cpdbofMgr = $self->figmodel()->database()->get_object_manager("cpdbof");
4288                    $cpdbofMgr->create({COMPOUND=>$compound,BIOMASS=>$biomassID,coefficient=>$equationCompounds->{$compound}->{coef},compartment=>"c",category=>$typeCategories->{$equationCompounds->{$compound}->{type}}});
4289            }
4290            print "Total mass = ".$totalmass.", Reactant mass = ".$reactantmass.", Product mass = ".$productmass."\n";
4291                  my $Equation = "";                  my $Equation = "";
4292                  my @ReactantList = sort(keys(%Reactants));          my @ReactantList = sort(keys(%{$reactants}));
4293                  for (my $i=0; $i < @ReactantList; $i++) {                  for (my $i=0; $i < @ReactantList; $i++) {
4294                          if (length($Equation) > 0) {                          if (length($Equation) > 0) {
4295                                  $Equation .= " + ";                                  $Equation .= " + ";
4296                          }                          }
4297                          $Equation .= $self->figmodel()->format_coefficient($Reactants{$ReactantList[$i]})." ".$ReactantList[$i];                  $Equation .= "(".$reactants->{$ReactantList[$i]}.") ".$ReactantList[$i];
4298                  }                  }
4299                  $Equation .= " => ";                  $Equation .= " => ";
4300                  my $First = 1;                  my $First = 1;
4301                  @ReactantList = sort(keys(%Products));          @ReactantList = sort(keys(%{$products}));
4302                  for (my $i=0; $i < @ReactantList; $i++) {                  for (my $i=0; $i < @ReactantList; $i++) {
4303                          if ($First == 0) {                          if ($First == 0) {
4304                                  $Equation .= " + ";                                  $Equation .= " + ";
4305                          }                          }
4306                          $First = 0;                          $First = 0;
4307                          $Equation .= $self->figmodel()->format_coefficient($Products{$ReactantList[$i]})." ".$ReactantList[$i];                  $Equation .= "(".$products->{$ReactantList[$i]}.") ".$ReactantList[$i];
4308            }
4309            $bioObj->equation($Equation);
4310            #Setting the biomass reaction of this model
4311            $self->biomassReaction($biomassID);
4312            $self->figmodel()->print_biomass_reaction_file($biomassID);
4313            #Checking if the biomass reaction remained unchanged
4314            if ($originalPackages ne "" && $originalPackages eq $bioObj->cofactorPackage().$bioObj->lipidPackage().$bioObj->cellWallPackage()) {
4315                    print "UNCHANGED!\n";
4316                    $bioObj->essentialRxn($originalEssReactions);
4317            } else {
4318                    #Copying essential reaction lists if the packages in this biomasses reaction exactly match those in another biomass reaction
4319                    my $matches = $bioMgr->get_objects({cofactorPackage=>$bioObj->cofactorPackage(),lipidPackage=>$bioObj->lipidPackage(),cellWallPackage=>$bioObj->cellWallPackage()});
4320                    my $matchFound = 0;
4321                    for (my $i=0; $i < @{$matches}; $i++) {
4322                            if ($matches->[$i]->id() ne $biomassID && defined($matches->[$i]->essentialRxn()) && length($matches->[$i]->essentialRxn())) {
4323                                    $bioObj->essentialRxn($matches->[$i]->essentialRxn());
4324                                    print "MATCH!\n";
4325                                    $matchFound = 1;
4326                                    last;
4327                  }                  }
   
                 #Adding the biomass equation to the biomass table  
                 my $NewRow = $self->figmodel()->add_biomass_reaction($Equation,$self->id(),"Template:".$self->genome());  
                 $biomassrxn = $NewRow;  
4328          }          }
4329          return $biomassrxn;                  #Otherwise, we calculate essential reactions
4330                    if ($matchFound == 0) {
4331                            print "NOMATCH!\n";
4332                            $self->figmodel()->determine_biomass_essential_reactions($biomassID);
4333                    }
4334            }
4335            return $biomassID;
4336  }  }
4337    
4338  =head3 PrintSBMLFile  =head3 PrintSBMLFile
# Line 3732  Line 4343 
4343  =cut  =cut
4344  sub PrintSBMLFile {  sub PrintSBMLFile {
4345          my($self) = @_;          my($self) = @_;
   
4346          #Opening the SBML file for printing          #Opening the SBML file for printing
4347          my $Filename = $self->config("SBML files")->[0].$self->id().".xml";          my $Filename = $self->directory().$self->id().".xml";
         if ($self->owner() ne "master") {  
                 if (!-d $self->config("SBML files")->[0].$self->owner()."/") {  
                         system("mkdir ".$self->config("SBML files")->[0].$self->owner()."/");  
                 }  
                 $Filename = $self->config("SBML files")->[0].$self->owner()."/".$self->id().".xml";  
         }  
4348          if (!open (SBMLOUTPUT, ">$Filename")) {          if (!open (SBMLOUTPUT, ">$Filename")) {
4349                  return;                  return;
4350          }          }
   
4351          #Loading and parsing the model data          #Loading and parsing the model data
4352          my $ModelTable = $self->reaction_table();          my $mdlTbl = $self->reaction_table();
4353          if (!defined($ModelTable) || !defined($ModelTable->{"array"})) {          if (!defined($mdlTbl) || !defined($mdlTbl->{"array"})) {
4354                  print "Failed to load ".$self->id()."\n";                  return $self->fail();
                 return;  
4355          }          }
4356            my $rxnMgr = $self->figmodel()->database()->get_object_manager("reaction");
4357            my $cmpTbl = $self->figmodel()->database()->get_table("COMPARTMENTS");
4358            my $cpdMgr = $self->figmodel()->database()->get_object_manager("compound");
4359            my $bioMgr = $self->figmodel()->database()->get_object_manager("bof");
4360          #Adding intracellular metabolites that also need exchange fluxes to the exchange hash          #Adding intracellular metabolites that also need exchange fluxes to the exchange hash
4361          my $ExchangeHash = {"cpd11416" => "c"};          my $ExchangeHash = {"cpd11416" => "c"};
   
4362          my %CompartmentsPresent;          my %CompartmentsPresent;
4363          $CompartmentsPresent{"c"} = 1;          $CompartmentsPresent{"c"} = 1;
4364          my %CompoundList;          my %CompoundList;
4365          my @ReactionList;          my @ReactionList;
4366          my $ReactionTable = $self->figmodel()->database()->GetDBTable("REACTIONS");          for (my $i=0; $i < $mdlTbl->size(); $i++) {
4367          for (my $i=0; $i < $ModelTable->size(); $i++) {                  my $rxnObj;
4368                  my $Reaction = $ModelTable->get_row($i)->{"LOAD"}->[0];                  if ($mdlTbl->get_row($i)->{"LOAD"}->[0] =~ m/rxn\d\d\d\d\d/) {
4369                  if (defined($ReactionTable->get_row_by_key($Reaction,"DATABASE")) && defined($ReactionTable->get_row_by_key($Reaction,"DATABASE")->{"EQUATION"}->[0])) {                          $rxnObj = $rxnMgr->get_objects({id=>$mdlTbl->get_row($i)->{"LOAD"}->[0]})->[0];
4370                          push(@ReactionList,$Reaction);                  } elsif ($mdlTbl->get_row($i)->{"LOAD"}->[0] =~ m/bio\d\d\d\d\d/) {
4371                          $_ = $ReactionTable->get_row_by_key($Reaction,"DATABASE")->{"EQUATION"}->[0];                          $rxnObj = $bioMgr->get_objects({id=>$mdlTbl->get_row($i)->{"LOAD"}->[0]})->[0];
4372                    }
4373                    if (!defined($rxnObj)) {
4374                            next;
4375                    }
4376                    push(@ReactionList,$rxnObj);
4377                    $_ = $rxnObj->equation();
4378                          my @MatchArray = /(cpd\d\d\d\d\d)/g;                          my @MatchArray = /(cpd\d\d\d\d\d)/g;
4379                          for (my $j=0; $j < @MatchArray; $j++) {                          for (my $j=0; $j < @MatchArray; $j++) {
4380                                  $CompoundList{$MatchArray[$j]}->{"c"} = 1;                                  $CompoundList{$MatchArray[$j]}->{"c"} = 1;
4381                          }                          }
4382                          $_ = $ReactionTable->get_row_by_key($Reaction,"DATABASE")->{"EQUATION"}->[0];                  $_ = $rxnObj->equation();
4383                          @MatchArray = /(cpd\d\d\d\d\d\[\D\])/g;                          @MatchArray = /(cpd\d\d\d\d\d\[\D\])/g;
4384                          for (my $j=0; $j < @MatchArray; $j++) {                          for (my $j=0; $j < @MatchArray; $j++) {
4385                                  if ($MatchArray[$j] =~ m/(cpd\d\d\d\d\d)\[(\D)\]/) {                                  if ($MatchArray[$j] =~ m/(cpd\d\d\d\d\d)\[(\D)\]/) {
# Line 3778  Line 4388 
4388                                  }                                  }
4389                          }                          }
4390                  }                  }
         }  
4391    
4392          #Printing header to SBML file          #Printing header to SBML file
4393          my $ModelName = $self->id();          my $ModelName = $self->id().$self->selected_version();
4394          $ModelName =~ s/\./_/;          $ModelName =~ s/\./_/;
4395          print SBMLOUTPUT '<?xml version="1.0" encoding="UTF-8"?>'."\n";          print SBMLOUTPUT '<?xml version="1.0" encoding="UTF-8"?>'."\n";
4396      print SBMLOUTPUT '<sbml xmlns="http://www.sbml.org/sbml/level2" level="2" version="1" xmlns:html="http://www.w3.org/1999/xhtml">' . "\n";      print SBMLOUTPUT '<sbml xmlns="http://www.sbml.org/sbml/level2" level="2" version="1" xmlns:html="http://www.w3.org/1999/xhtml">' . "\n";
4397      if (defined($self->figmodel()->database()->GetDBTable("MODEL STATS")->{$self->id()}->[0]->{"Organism name"}->[0])) {          if (defined($self->name())) {
4398          print SBMLOUTPUT '<model id="'.$ModelName.'" name="'.$self->figmodel()->database()->GetDBTable("MODEL STATS")->{$self->id()}->[0]->{"Organism name"}->[0].' SEED model">'."\n";                  print SBMLOUTPUT '<model id="'.$ModelName.'" name="'.$self->name().' SEED model">'."\n";
4399      } else {      } else {
4400          print SBMLOUTPUT '<model id="'.$ModelName.'" name="'.$self->id().' SEED model">'."\n";                  print SBMLOUTPUT '<model id="'.$ModelName.'" name="'.$self->id().$self->selected_version().' SEED model">'."\n";
4401      }      }
4402    
4403          #Printing the unit data          #Printing the unit data
# Line 3805  Line 4414 
4414      #Printing compartments for SBML file      #Printing compartments for SBML file
4415      print SBMLOUTPUT '<listOfCompartments>'."\n";      print SBMLOUTPUT '<listOfCompartments>'."\n";
4416      foreach my $Compartment (keys(%CompartmentsPresent)) {      foreach my $Compartment (keys(%CompartmentsPresent)) {
4417          if (defined($self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Compartment}->[0]->{"Name"}->[0])) {                  my $row = $cmpTbl->get_row_by_key($Compartment,"Abbreviation");
4418                  my @OutsideList = split(/\//,$self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Compartment}->[0]->{"Outside"}->[0]);                  if (!defined($row) && !defined($row->{"Name"}->[0])) {
4419                            next;
4420                    }
4421                    my @OutsideList = split(/\//,$row->{"Outside"}->[0]);
4422                  my $Printed = 0;                  my $Printed = 0;
4423                  foreach my $Outside (@OutsideList) {                  foreach my $Outside (@OutsideList) {
4424                                  if (defined($CompartmentsPresent{$Outside}) && defined($self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Outside}->[0]->{"Name"}->[0])) {                          if (defined($CompartmentsPresent{$Outside}) && defined($row->{"Name"}->[0])) {
4425                                  print SBMLOUTPUT '<compartment id="'.$self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Compartment}->[0]->{"Name"}->[0].'" outside="'.$self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Outside}->[0]->{"Name"}->[0].'"/>'."\n";                                  print SBMLOUTPUT '<compartment id="'.$row->{"Name"}->[0].'" outside="'.$row->{"Name"}->[0].'"/>'."\n";
4426                                  $Printed = 1;                                  $Printed = 1;
4427                                  last;                                  last;
4428                          }                          }
4429                  }                  }
4430                  if ($Printed eq 0) {                  if ($Printed eq 0) {
4431                          print SBMLOUTPUT '<compartment id="'.$self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Compartment}->[0]->{"Name"}->[0].'"/>'."\n";                          print SBMLOUTPUT '<compartment id="'.$row->{"Name"}->[0].'"/>'."\n";
                         }  
4432          }          }
4433      }      }
4434      print SBMLOUTPUT '</listOfCompartments>'."\n";      print SBMLOUTPUT '</listOfCompartments>'."\n";
# Line 3825  Line 4436 
4436      #Printing the list of metabolites involved in the model      #Printing the list of metabolites involved in the model
4437          print SBMLOUTPUT '<listOfSpecies>'."\n";          print SBMLOUTPUT '<listOfSpecies>'."\n";
4438      foreach my $Compound (keys(%CompoundList)) {      foreach my $Compound (keys(%CompoundList)) {
4439          my $Name = $Compound;                  my $cpdObj = $cpdMgr->get_objects({id=>$Compound})->[0];
4440                    if (!defined($cpdObj)) {
4441                            next;
4442                    }
4443                  my $Formula = "";                  my $Formula = "";
4444                  if (defined($self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"FORMULA"}->[0])) {                  if (defined($cpdObj->formula())) {
4445                          $Formula = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"FORMULA"}->[0];                          $Formula = $cpdObj->formula();
4446                  }                  }
4447                  if (defined($self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"NAME"}->[0])) {                  my $Name = $cpdObj->name();
                         $Name = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"NAME"}->[0];  
4448                          $Name =~ s/\s/_/;                          $Name =~ s/\s/_/;
4449                          $Name .= "_".$Formula;                          $Name .= "_".$Formula;
                 }  
4450                  $Name =~ s/[<>;&\*]//;                  $Name =~ s/[<>;&\*]//;
4451                  my $Charge = 0;                  my $Charge = 0;
4452                  if (defined($self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"CHARGE"}->[0])) {                  if (defined($cpdObj->charge())) {
4453                          $Charge = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"CHARGE"}->[0];                          $Charge = $cpdObj->charge();
4454                  }                  }
4455                  foreach my $Compartment (keys(%{$CompoundList{$Compound}})) {                  foreach my $Compartment (keys(%{$CompoundList{$Compound}})) {
4456                  if ($Compartment eq "e") {                  if ($Compartment eq "e") {
4457                          $ExchangeHash->{$Compound} = "e";                          $ExchangeHash->{$Compound} = "e";
4458                  }                  }
4459                  print SBMLOUTPUT '<species id="'.$Compound.'_'.$Compartment.'" name="'.$Name.'" compartment="'.$self->figmodel()->database()->GetDBTable("COMPARTMENTS")->{$Compartment}->[0]->{"Name"}->[0].'" charge="'.$Charge.'" boundaryCondition="false"/>'."\n";                          my $cmprow = $cmpTbl->get_row_by_key($Compartment,"Abbreviation");
4460                            print SBMLOUTPUT '<species id="'.$Compound.'_'.$Compartment.'" name="'.$Name.'" compartment="'.$cmprow->{"Name"}->[0].'" charge="'.$Charge.'" boundaryCondition="false"/>'."\n";
4461          }          }
4462      }      }
4463    
4464          #Printing the boundary species          #Printing the boundary species
4465          foreach my $Compound (keys(%{$ExchangeHash})) {          foreach my $Compound (keys(%{$ExchangeHash})) {
4466                  my $Name = $Compound;                  my $cpdObj = $cpdMgr->get_objects({id=>$Compound})->[0];
4467                    if (!defined($cpdObj)) {
4468                            next;
4469                    }
4470                  my $Formula = "";                  my $Formula = "";
4471                  if (defined($self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"FORMULA"}->[0])) {                  if (defined($cpdObj->formula())) {
4472                          $Formula = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"FORMULA"}->[0];                          $Formula = $cpdObj->formula();
4473                  }                  }
4474                  if (defined($self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"NAME"}->[0])) {                  my $Name = $cpdObj->name();
                         $Name = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"NAME"}->[0];  
4475                          $Name =~ s/\s/_/;                          $Name =~ s/\s/_/;
4476                          $Name .= "_".$Formula;                          $Name .= "_".$Formula;
                 }  
4477                  $Name =~ s/[<>;&\*]//;                  $Name =~ s/[<>;&\*]//;
4478                  my $Charge = 0;                  my $Charge = 0;
4479                  if (defined($self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"CHARGE"}->[0])) {                  if (defined($cpdObj->charge())) {
4480                          $Charge = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->{$Compound}->[0]->{"CHARGE"}->[0];                          $Charge = $cpdObj->charge();
4481                  }                  }
4482                  print SBMLOUTPUT '<species id="'.$Compound.'_b" name="'.$Name.'" compartment="Extracellular" charge="'.$Charge.'" boundaryCondition="true"/>'."\n";                  print SBMLOUTPUT '<species id="'.$Compound.'_b" name="'.$Name.'" compartment="Extracellular" charge="'.$Charge.'" boundaryCondition="true"/>'."\n";
4483          }          }
# Line 3871  Line 4486 
4486      #Printing the list of reactions involved in the model      #Printing the list of reactions involved in the model
4487          my $ObjectiveCoef;          my $ObjectiveCoef;
4488      print SBMLOUTPUT '<listOfReactions>'."\n";      print SBMLOUTPUT '<listOfReactions>'."\n";
4489          foreach my $Reaction (@ReactionList) {  
4490            foreach my $rxnObj (@ReactionList) {
4491          $ObjectiveCoef = "0.0";          $ObjectiveCoef = "0.0";
4492                  if (defined($self->figmodel()->database()->GetDBTable("REACTIONS")->{$Reaction}->[0]->{"EQUATION"}->[0])) {                  my $mdlrow = $mdlTbl->get_row_by_key($rxnObj->id(),"LOAD");
4493                  if ($Reaction =~ m/^bio/) {                  if ($rxnObj->id() =~ m/^bio/) {
4494                                  $ObjectiveCoef = "1.0";                                  $ObjectiveCoef = "1.0";
4495                          }                          }
4496                          my $LowerBound = -10000;                          my $LowerBound = -10000;
4497                  my $UpperBound = 10000;                  my $UpperBound = 10000;
4498                          my ($Reactants,$Products) = $self->figmodel()->GetReactionSubstrateData($Reaction);                  my ($Reactants,$Products) = $self->figmodel()->GetReactionSubstrateDataFromEquation($rxnObj->equation());
4499                  my $Name = $Reaction;                  my $Name = $rxnObj->name();
                 if (defined($self->figmodel()->database()->GetDBTable("REACTIONS")->{$Reaction}->[0]->{"NAME"}->[0])) {  
                         $Name = $self->figmodel()->database()->GetDBTable("REACTIONS")->{$Reaction}->[0]->{"NAME"}->[0];  
4500                                  $Name =~ s/[<>;&]//g;                                  $Name =~ s/[<>;&]//g;
                 }  
4501                  my $Reversibility = "true";                  my $Reversibility = "true";
4502                  if (defined($ModelTable->{$Reaction}->[0]->{"DIRECTIONALITY"}->[0])) {                  if (defined($mdlrow->{"DIRECTIONALITY"}->[0])) {
4503                          if ($ModelTable->{$Reaction}->[0]->{"DIRECTIONALITY"}->[0] ne "<=>") {                          if ($mdlrow->{"DIRECTIONALITY"}->[0] ne "<=>") {
4504                                  $LowerBound = 0;                                  $LowerBound = 0;
4505                                          $Reversibility = "false";                                          $Reversibility = "false";
4506                          }                          }
4507                          if ($ModelTable->{$Reaction}->[0]->{"DIRECTIONALITY"}->[0] eq "<=") {                          if ($mdlrow->{"DIRECTIONALITY"}->[0] eq "<=") {
4508                                  my $Temp = $Products;                                  my $Temp = $Products;
4509                                  $Products = $Reactants;                                  $Products = $Reactants;
4510                                  $Reactants = $Temp;                                  $Reactants = $Temp;
4511                          }                          }
4512                  }                  }
4513                          print SBMLOUTPUT '<reaction id="'.$Reaction.'" name="'.$Name.'" reversible="'.$Reversibility.'">'."\n";                  print SBMLOUTPUT '<reaction id="'.$rxnObj->id().'" name="'.$Name.'" reversible="'.$Reversibility.'">'."\n";
4514                          print SBMLOUTPUT "<notes>\n";                          print SBMLOUTPUT "<notes>\n";
4515                          my $ECData = "";                          my $ECData = "";
4516                          if (defined($self->figmodel()->database()->GetDBTable("REACTIONS")->{$Reaction}->[0]->{"ENZYME"}->[0])) {                  if ($rxnObj->id() !~ m/^bio/) {
4517                                  $ECData = $self->figmodel()->database()->GetDBTable("REACTIONS")->{$Reaction}->[0]->{"ENZYME"}->[0];                          if (defined($rxnObj->enzyme())) {
4518                                    my @ecList = split(/\|/,$rxnObj->enzyme());
4519                                    if (defined($ecList[1])) {
4520                                            $ECData = $ecList[1];
4521                                    }
4522                            }
4523                          }                          }
4524                          my $SubsystemData = "";                          my $SubsystemData = "";
4525                          if (defined($ModelTable->{$Reaction}->[0]->{"SUBSYSTEM"}->[0])) {                  if (defined($mdlrow->{"SUBSYSTEM"}->[0])) {
4526                                  $SubsystemData = $ModelTable->{$Reaction}->[0]->{"SUBSYSTEM"}->[0];                          $SubsystemData = $mdlrow->{"SUBSYSTEM"}->[0];
4527                          }                          }
4528                          my $GeneAssociation = "";                          my $GeneAssociation = "";
4529                          my $ProteinAssociation = "";                          my $ProteinAssociation = "";
4530                          if (defined($ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}->[0])) {                  if (defined($mdlrow->{"ASSOCIATED PEG"}->[0])) {
4531                                  if (@{$ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}} == 1 && $ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}->[0] !~ m/\+/) {                          if (@{$mdlrow->{"ASSOCIATED PEG"}} == 1 && $mdlrow->{"ASSOCIATED PEG"}->[0] !~ m/\+/) {
4532                                          $GeneAssociation = $ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}->[0];                                  $GeneAssociation = $mdlrow->{"ASSOCIATED PEG"}->[0];
4533                                  } else {                                  } else {
4534                                          if (@{$ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}} > 1) {                                  if (@{$mdlrow->{"ASSOCIATED PEG"}} > 1) {
4535                                                  $GeneAssociation = "( ";                                                  $GeneAssociation = "( ";
4536                                          }                                          }
4537                                          for (my $i=0; $i < @{$ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}}; $i++) {                                  for (my $i=0; $i < @{$mdlrow->{"ASSOCIATED PEG"}}; $i++) {
4538                                                  if ($i > 0) {                                                  if ($i > 0) {
4539                                                          $GeneAssociation .= " )  or  ( ";                                                          $GeneAssociation .= " )  or  ( ";
4540                                                  }                                                  }
4541                                                  $GeneAssociation .= $ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}->[$i];                                          $GeneAssociation .= $mdlrow->{"ASSOCIATED PEG"}->[$i];
4542                                          }                                          }
4543                                          if (@{$ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}} > 1) {                                  if (@{$mdlrow->{"ASSOCIATED PEG"}} > 1) {
4544                                                  $GeneAssociation .= " )";                                                  $GeneAssociation .= " )";
4545                                          }                                          }
4546                                  }                                  }
# Line 3931  Line 4549 
4549                                          $GeneAssociation = "( ".$GeneAssociation." )";                                          $GeneAssociation = "( ".$GeneAssociation." )";
4550                                  }                                  }
4551                                  $ProteinAssociation = $GeneAssociation;                                  $ProteinAssociation = $GeneAssociation;
4552                                  if (defined($self->figmodel()->database()->GetDBTable("MODEL STATS")->{$self->id()}->[0]->{"Genome ID"}->[0])) {                          if (defined($self->genome())) {
4553                                          $ProteinAssociation = $self->figmodel()->translate_gene_to_protein($ModelTable->{$Reaction}->[0]->{"ASSOCIATED PEG"}->[0],$self->figmodel()->database()->GetDBTable("MODEL STATS")->{$self->id()}->[0]->{"Genome ID"}->[0]);                                  $ProteinAssociation = $self->figmodel()->translate_gene_to_protein($mdlrow->{"ASSOCIATED PEG"}->[0],$self->genome());
4554                                  }                                  }
4555                          }                          }
4556                          print SBMLOUTPUT "<html:p>GENE_ASSOCIATION:".$GeneAssociation."</html:p>\n";                          print SBMLOUTPUT "<html:p>GENE_ASSOCIATION:".$GeneAssociation."</html:p>\n";
# Line 3963  Line 4581 
4581              print SBMLOUTPUT "</kineticLaw>\n";              print SBMLOUTPUT "</kineticLaw>\n";
4582                          print SBMLOUTPUT '</reaction>'."\n";                          print SBMLOUTPUT '</reaction>'."\n";
4583                  }                  }
         }  
4584    
4585          my @ExchangeList = keys(%{$ExchangeHash});          my @ExchangeList = keys(%{$ExchangeHash});
4586          foreach my $ExCompound (@ExchangeList) {          foreach my $ExCompound (@ExchangeList) {
4587                  my $ExCompoundName = $ExCompound;                  my $cpdObj = $cpdMgr->get_objects({id=>$ExCompound})->[0];
4588                  my $Row = $self->figmodel()->database()->GetDBTable("COMPOUNDS")->get_row_by_key($ExCompound,"DATABASE");                  if (!defined($cpdObj)) {
4589                  if (defined($Row) && defined($Row->{"NAME"}->[0])) {                          next;
                         $ExCompoundName = $Row->{"NAME"}->[0];  
                         $ExCompoundName =~ s/[<>;&]//g;  
4590                  }                  }
4591                    my $ExCompoundName = $cpdObj->name();
4592                    $ExCompoundName =~ s/[<>;&]//g;
4593                  $ObjectiveCoef = "0.0";                  $ObjectiveCoef = "0.0";
4594                  print SBMLOUTPUT '<reaction id="EX_'.$ExCompound.'_'.$ExchangeHash->{$ExCompound}.'" name="EX_'.$ExCompoundName.'_'.$ExchangeHash->{$ExCompound}.'" reversible="true">'."\n";                  print SBMLOUTPUT '<reaction id="EX_'.$ExCompound.'_'.$ExchangeHash->{$ExCompound}.'" name="EX_'.$ExCompoundName.'_'.$ExchangeHash->{$ExCompound}.'" reversible="true">'."\n";
4595                  print SBMLOUTPUT "\t".'<notes>'."\n";                  print SBMLOUTPUT "\t".'<notes>'."\n";
# Line 4025  Line 4642 
4642                  $tbl->add_row($row);                  $tbl->add_row($row);
4643          }          }
4644          $tbl->save();          $tbl->save();
         system("cp ".$tbl->filename()." ".$self->figmodel()->config("Model table download directory")->[0].$self->figmodel()->config("ModelSimpleReactionTable")->{filename_prefix}->[0]."-".$self->id().".txt");  
4645  }  }
4646    
4647  =head3 PrintModelLPFile  =head3 PrintModelLPFile
# Line 4035  Line 4651 
4651          Prints the lp file needed to run the model using the mpifba program          Prints the lp file needed to run the model using the mpifba program
4652  =cut  =cut
4653  sub PrintModelLPFile {  sub PrintModelLPFile {
4654          my ($self) = @_;          my ($self,$exportForm) = @_;
4655          #Printing lp and key file for model          #Printing lp and key file for model
4656          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
4657          #Printing the standard FBA file          #Printing the standard FBA file
4658            if (defined($exportForm) && $exportForm == 1) {
4659                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),"NoBounds",["ProdFullFBALP"],{"Make all reactions reversible in MFA"=>0,"use simple variable and constraint names"=>0},$self->id().$self->selected_version()."-LPPrint.log",undef,$self->selected_version()));
4660                    system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/CurrentProblem.lp ".$self->directory().$self->id().$self->selected_version().".lp");
4661            } else {
4662          system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),"NoBounds",["ProdFullFBALP"],undef,$self->id().$self->selected_version()."-LPPrint.log",undef,$self->selected_version()));          system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),"NoBounds",["ProdFullFBALP"],undef,$self->id().$self->selected_version()."-LPPrint.log",undef,$self->selected_version()));
4663          system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/CurrentProblem.lp ".$self->directory()."FBA-".$self->id().$self->selected_version().".lp");          system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/CurrentProblem.lp ".$self->directory()."FBA-".$self->id().$self->selected_version().".lp");
4664            }
4665          my $KeyTable = FIGMODELTable::load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/VariableKey.txt",";","|",0,undef);          my $KeyTable = FIGMODELTable::load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/VariableKey.txt",";","|",0,undef);
4666          if (!defined($KeyTable)) {          if (!defined($KeyTable)) {
4667                  print STDERR "FIGMODEL:RunAllStudiesWithDataFast: ".$self->id()." LP file could not be printed.\n";                  print STDERR "FIGMODEL:RunAllStudiesWithDataFast: ".$self->id()." LP file could not be printed.\n";
# Line 4054  Line 4675 
4675    
4676  =head3 patch_model  =head3 patch_model
4677  Definition:  Definition:
4678          FIGMODELTable:patch results = FIGMODELmodel->patch_model(FIGMODELTable:patch table);          FIGMODELmodel->patch_model([] -or- {} of patch arguments);
4679  Description:  Description:
4680  =cut  =cut
4681  sub patch_model {  sub patch_model {
4682          my ($self,$tbl) = @_;          my ($self,$arguments) = @_;
4683            if ($self->id() =~ m/Seed/) {
4684          #Instantiating table                  print "Model qualifies.";
4685          my $results = FIGMODELTable->new(["Reactions","New genes","Old genes","Genes","Roles","Status"],$self->directory()."PatchResults-".$self->id().$self->selected_version().".tbl",["Reaction"],"\t",";",undef);                  #$self->BuildSpecificBiomassReaction();
4686          #Getting genome annotations                  #my $reactionTable = $self->reaction_table();
4687          my $features = $self->figmodel()->database()->get_genome_feature_table($self->genome());                  #my $row = $reactionTable->get_row_by_key("rxn05294","LOAD");
4688          #Gettubg reaction table                  #if (defined($row)) {
4689          my $reactions = $self->reaction_table();                  #       $reactionTable->delete_row($reactionTable->row_index($row));
4690          #Checking for patched roles                  #}
4691          for (my $i=0; $i < $tbl->size(); $i++) {                  #$row = $reactionTable->get_row_by_key("rxn05295","LOAD");
4692                  my $row = $tbl->get_row($i);                  #if (defined($row)) {
4693                  my @genes = $features->get_rows_by_key($row->{ROLE}->[0],"ROLES");                  #       $reactionTable->delete_row($reactionTable->row_index($row));
4694                  if (@genes > 0) {                  #}
4695                          for (my $j=0; $j < @{$row->{REACTIONS}};$j++) {                  #$row = $reactionTable->get_row_by_key("rxn05296","LOAD");
4696                                  my $resultrxn = $results->get_row_by_key($row->{REACTIONS}->[$j],"Reactions");                  #if (defined($row)) {
4697                                  if (!defined($resultrxn)) {                  #       $reactionTable->delete_row($reactionTable->row_index($row));
4698                                          $resultrxn = $results->add_row({"Reactions"=>[$row->{REACTIONS}->[$j]],"Roles"=>[$row->{ROLE}->[0]]});                  #}
4699                                  }                  #$row = $reactionTable->get_row_by_key($self->biomassReaction(),"LOAD");
4700                                  my $rxnrow = $reactions->get_row_by_key($row->{REACTIONS}->[$j],"LOAD");                  #delete $row->{"ASSOCIATED PEG"};
4701                                  if (defined($rxnrow) && !defined($resultrxn->{"Old genes"})) {                  #$row->{"ASSOCIATED PEG"}->[0] = "UNIVERSAL";
4702                                          $resultrxn->{"Old genes"} = $rxnrow->{"ASSOCIATED PEG"};                  #my $rxnHash = $self->generate_gpr_hash();
4703                                          if ($resultrxn->{"Old genes"}->[0] !~ m/GAP|BOF|UNIVERSAL|SPONTANEOUS/) {                  #$reactionTable->add_row({LOAD=>["rxn13782"],DIRECTIONALITY=>["=>"],COMPARTMENT=>["c"],"ASSOCIATED PEG"=>$rxnHash->{rxn13782}->{"GENES"},SUBSYSTEM=>["Macromolecule biosynthesis"],CONFIDENCE=>[4],REFERENCE=>["CHRIS FILE"],NOTES=>["NONE"]});
4704                                                  push(@{$resultrxn->{"Genes"}},@{$resultrxn->{"Old genes"}});                  #$reactionTable->add_row({LOAD=>["rxn13783"],DIRECTIONALITY=>["=>"],COMPARTMENT=>["c"],"ASSOCIATED PEG"=>$rxnHash->{rxn13783}->{"GENES"},SUBSYSTEM=>["Macromolecule biosynthesis"],CONFIDENCE=>[4],REFERENCE=>["CHRIS FILE"],NOTES=>["NONE"]});
4705                                          }                  #$reactionTable->add_row({LOAD=>["rxn13784"],DIRECTIONALITY=>["=>"],COMPARTMENT=>["c"],"ASSOCIATED PEG"=>$rxnHash->{rxn13784}->{"GENES"},SUBSYSTEM=>["Macromolecule biosynthesis"],CONFIDENCE=>[4],REFERENCE=>["CHRIS FILE"],NOTES=>["NONE"]});
4706                                  }                  #$reactionTable->save();
4707                                  delete $resultrxn->{"Current gene set"};                  $self->PrintSBMLFile();
4708                                  if (defined($resultrxn->{"Genes"})) {                  $self->PrintModelLPFile();
4709                                          push(@{$resultrxn->{"Current gene set"}},@{$resultrxn->{"Genes"}});                  $self->PrintModelLPFile(1);
4710                                  }                  $self->PrintModelSimpleReactionTable();
4711                                  for (my $k=0; $k < @genes; $k++) {                  $self->update_model_stats();
4712                                          if ($genes[$k]->{ID}->[0] =~ m/(peg\.\d+)/) {                  $self->calculate_growth();
4713                                                  my $gene = $1;                  if ($self->growth() != 0) {
4714                                                  my $addgene = 1;                          $self->run_default_model_predictions();
                                                 if (defined($resultrxn->{"Old genes"})) {  
                                                         for (my $m=0; $m < @{$resultrxn->{"Old genes"}}; $m++) {  
                                                                 if ($resultrxn->{"Old genes"}->[$m] =~ m/$gene/) {  
                                                                         $addgene = 0;  
                                                                 }  
                                                         }  
4715                                                  }                                                  }
4716                                                  if ($addgene == 1) {                  print "Patch complete.\n";
                                                         push(@{$resultrxn->{"New genes"}},$gene);  
                                                         if ($row->{COMPLEX}->[0] ne "0" && defined($resultrxn->{"Current gene set"})) {  
                                                                 my $added = 0;  
                                                                 for (my $m=0; $m < @{$resultrxn->{"Current gene set"}}; $m++) {  
                                                                         if ($row->{COMPLEX}->[0] eq "1") {  
                                                                                 $resultrxn->{"Current gene set"}->[$m] = $resultrxn->{"Current gene set"}->[$m]."+".$gene;  
                                                                                 $added = 1;  
                                                                         } else {  
                                                                                 my @geneset = split(/\+/,$resultrxn->{"Current gene set"}->[$m]);  
                                                                                 for (my $n=0; $n < @geneset;$n++) {  
                                                                                         if ($self->figmodel()->colocalized_genes($geneset[$n],$gene,$self->genome()) == 1) {  
                                                                                                 $resultrxn->{"Current gene set"}->[$m] = $resultrxn->{"Current gene set"}->[$m]."+".$gene;  
                                                                                                 $added = 1;  
                                                                                                 last;  
4717                                                                                          }                                                                                          }
4718                                                                                  }                                                                                  }
4719    
4720    =head3 integrateUploadedChanges
4721    Definition:
4722            FIGMODELmodel->integrateUploadedChanges();
4723    Description:
4724    =cut
4725    sub integrateUploadedChanges {
4726            my ($self,$username) = @_;
4727            if (!-e $self->directory().$self->id()."-uploadtable.tbl") {
4728                    $self->error_message("integrateUploadedChanges:uploaded file not found for model!");
4729                    return undef;
4730                                                                          }                                                                          }
4731            my $tbl = $self->load_model_table("ModelReactionUpload",1);
4732            if (!defined($tbl)) {
4733                    $self->error_message("integrateUploadedChanges:could not load uploaded reaction table!");
4734                    return undef;
4735                                                                  }                                                                  }
4736                                                                  if ($added == 0) {          my $newrxntbl = $self->reaction_table(1);
4737                                                                          push(@{$resultrxn->{"Current gene set"}},$gene);          if (!defined($newrxntbl)) {
4738                    $self->error_message("integrateUploadedChanges:could not load reaction table!");
4739                    return undef;
4740                                                                  }                                                                  }
4741            for (my $i=0; $i < $newrxntbl->size(); $i++) {
4742                    my $row = $newrxntbl->get_row($i);
4743                    my $newrow = $tbl->get_row_by_key($row->{LOAD}->[0],"DATABASE");
4744                    if (!defined($newrow)) {
4745                            $newrxntbl->delete_row($i);
4746                            $i--;
4747                                                          } else {                                                          } else {
4748                                                                  push(@{$resultrxn->{"Current gene set"}},$gene);                          $row->{DIRECTIONALITY} = $newrow->{DIRECTIONALITY};
4749                                                          }                          $row->{COMPARTMENT} = $newrow->{COMPARTMENT};
4750                                                  }                          $row->{"ASSOCIATED PEG"} = $newrow->{"ASSOCIATED PEG"};
4751                            $row->{NOTES} = $newrow->{NOTES};
4752                                          }                                          }
4753                                  }                                  }
4754                                  delete $resultrxn->{"Genes"};          for (my $i=0; $i < $tbl->size(); $i++) {
4755                                  push(@{$resultrxn->{"Genes"}},@{$resultrxn->{"Current gene set"}});                  my $row = $tbl->get_row($i);
4756                          }                  my $newrow = $newrxntbl->get_row_by_key($row->{DATABASE}->[0],"LOAD");
4757                  }                  if (!defined($newrow)) {
4758          }                          $newrxntbl->add_row({LOAD=>$row->{DATABASE},DIRECTIONALITY=>$row->{DIRECTIONALITY},COMPARTMENT=>$row->{COMPARTMENT},"ASSOCIATED PEG"=>$row->{"ASSOCIATED PEG"},SUBSYSTEM=>["NONE"],CONFIDENCE=>[5],REFERENCE=>["NONE"],NOTES=>$row->{NOTES}});
   
         #Ensuring that the old model is preserved  
         $self->ArchiveModel();  
         #Modifing the reaction list  
         for (my $i=0; $i < $results->size();$i++) {  
                 my $row = $results->get_row($i);  
                 my $rxnrow = $reactions->get_row_by_key($row->{"Reactions"}->[0],"LOAD");  
                 if (defined($rxnrow)) {  
                         $rxnrow->{"ASSOCIATED PEG"} = $row->{"Genes"};  
                 } else {  
                         $reactions->add_row({LOAD=>[$row->{"Reactions"}->[0]],DIRECTIONALITY=>[$self->figmodel()->reversibility_of_reaction($row->{"Reactions"}->[0])],COMPARTMENT=>["c"],"ASSOCIATED PEG"=>$row->{"Genes"},SUBSYSTEM=>["NONE"],CONFIDENCE=>[2],REFERENCE=>["NONE"],NOTES=>["PATCH"]});  
4759                  }                  }
4760          }          }
4761          $reactions->save();          $self->calculate_model_changes($self->reaction_table(1),$username." modifications",$newrxntbl);
4762          $results->save();          $newrxntbl->save();
4763          $self->update_model_stats();          $self->PrintSBMLFile();
4764          $self->PrintModelLPFile();          $self->PrintModelLPFile();
4765          $self->run_default_model_predictions();          $self->PrintModelLPFile(1);
4766          #Returning results          $self->PrintModelSimpleReactionTable();
4767          return $results;          $self->update_model_stats();
4768            my $growth = $self->calculate_growth()
4769    
4770            #;
4771                    #if ($growth =~ m/^NOGROWTH/ ||  $growth < 1e-5) {
4772                    #       $self->error_message("patch_model:model did not grow, gapfilling!");
4773                    #       $self->GapFillModel(1);
4774                    #       $growth = $self->calculate_growth();
4775                    #       if ($growth =~ m/^NOGROWTH/ ||  $growth < 1e-5) {
4776                    #               $self->error_message("patch_model:model still did not grow!");
4777                    #               print "Patch failed.\n";
4778                    #               return;
4779                    #       }
4780                    #}
4781                    #$self->run_default_model_predictions();
4782  }  }
4783    
4784  =head3 translate_genes  =head3 translate_genes
# Line 4354  Line 4982 
4982          }          }
4983  }  }
4984    
4985    =pod
4986    
4987    =item * [string]:I<list of essential genes> = B<run_geneKO_slow> (string:I<media>,0/1:I<max growth>,0/1:I<save results>);
4988    
4989    =cut
4990    
4991    sub run_geneKO_slow {
4992            my ($self,$media,$maxGrowth,$save) = @_;
4993            my $output;
4994            my $UniqueFilename = $self->figmodel()->filename();
4995            if (defined($maxGrowth) && $maxGrowth == 1) {
4996                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$media,["ProductionMFA"],{"perform single KO experiments" => 1,"MFASolver" => "GLPK","Constrain objective to this fraction of the optimal value" => 0.999},"SlowGeneKO-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,$self->selected_version()));
4997            } else {
4998                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$media,["ProductionMFA"],{"perform single KO experiments" => 1,"MFASolver" => "GLPK","Constrain objective to this fraction of the optimal value" => 0.1},"SlowGeneKO-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,$self->selected_version()));
4999            }
5000            if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."DeletionStudyResults.txt") {
5001                    print "Deletion study file not found!.\n";
5002                    return undef;
5003            }
5004            my $deltbl = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."DeletionStudyResults.txt",";","|",1,["Experiment"]);
5005            for (my $i=0; $i < $deltbl->size(); $i++) {
5006                    my $row = $deltbl->get_row($i);
5007                    if ($row->{"Insilico growth"}->[0] < 0.0000001) {
5008                            push(@{$output},$row->{Experiment}->[0]);
5009                    }
5010            }
5011            if (defined($output)) {
5012                    if (defined($save) && $save == 1) {
5013                            my $tbl = $self->essentials_table();
5014                            my $row = $tbl->get_row_by_key($media,"MEDIA",1);
5015                            $row->{"ESSENTIAL GENES"} = $output;
5016                            $tbl->save();
5017                    }
5018            }
5019            return $output;
5020    }
5021    
5022    =pod
5023    
5024    =item * [string]:I<list of minimal genes> = B<run_gene_minimization> (string:I<media>,0/1:I<max growth>,0/1:I<save results>);
5025    
5026    =cut
5027    
5028    sub run_gene_minimization {
5029            my ($self,$media,$maxGrowth,$save) = @_;
5030            my $output;
5031    
5032            #Running the MFAToolkit
5033            my $UniqueFilename = $self->figmodel()->filename();
5034            if (defined($maxGrowth) && $maxGrowth == 1) {
5035                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$media,["ProductionMFA"],{"optimize organism genes" => 1,"MFASolver" => "CPLEX","Constrain objective to this fraction of the optimal value" => 0.999},"MinimizeGenes-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,$self->selected_version()));
5036            } else {
5037                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$media,["ProductionMFA"],{"optimize organism genes" => 1,"MFASolver" => "CPLEX","Constrain objective to this fraction of the optimal value" => 0.1},"MinimizeGenes-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,$self->selected_version()));
5038            }
5039            my $tbl = $self->figmodel()->LoadProblemReport($UniqueFilename);
5040            if (!defined($tbl)) {
5041                    return undef;
5042            }
5043            for (my $i=0; $i < $tbl->size(); $i++) {
5044                    my $row = $tbl->get_row($i);
5045                    if ($row->{Notes}->[0] =~ m/Recursive\sMILP\sGENE_USE\soptimization/) {
5046                            my @array = split(/\|/,$row->{Notes}->[0]);
5047                            my $solution = $array[0];
5048                            $_ = $solution;
5049                            my @OriginalArray = /(peg\.\d+)/g;
5050                            push(@{$output},@OriginalArray);
5051                            last;
5052                    }
5053            }
5054    
5055            if (defined($output)) {
5056                    if (defined($save) && $save == 1) {
5057                            my $tbl = $self->load_model_table("MinimalGenes");
5058                            my $row = $tbl->get_table_by_key("MEDIA",$media)->get_row_by_key("MAXGROWTH",$maxGrowth);
5059                            if (defined($row)) {
5060                                    $row->{GENES} = $output;
5061                            } else {
5062                                    $tbl->add_row({GENES => $output,MEDIA => [$media],MAXGROWTH => [$maxGrowth]});
5063                            }
5064                            $tbl->save();
5065                    }
5066            }
5067            return $output;
5068    }
5069    
5070    =pod
5071    
5072    =item * [string]:I<list of inactive genes> = B<identify_inactive_genes> (string:I<media>,0/1:I<max growth>,0/1:I<save results>);
5073    
5074    =cut
5075    
5076    sub identify_inactive_genes {
5077            my ($self,$media,$maxGrowth,$save) = @_;
5078            my $output;
5079            #Running the MFAToolkit
5080            my $UniqueFilename = $self->figmodel()->filename();
5081            if (defined($maxGrowth) && $maxGrowth == 1) {
5082                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$media,["ProductionMFA"],{"find tight bounds" => 1,"MFASolver" => "GLPK","Constrain objective to this fraction of the optimal value" => 0.999},"Classify-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,$self->selected_version()));
5083            } else {
5084                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$media,["ProductionMFA"],{"find tight bounds" => 1,"MFASolver" => "GLPK","Constrain objective to this fraction of the optimal value" => 0.1},"Classify-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,$self->selected_version()));
5085            }
5086            #Reading in the output bounds file
5087            my $ReactionTB;
5088            if (-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/MFAOutput/TightBoundsReactionData0.txt") {
5089                    $ReactionTB = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/MFAOutput/TightBoundsReactionData0.txt",";","|",1,["DATABASE ID"]);
5090            }
5091            if (!defined($ReactionTB)) {
5092                    print STDERR "FIGMODEL:ClassifyModelReactions: Classification file not found when classifying reactions in ".$self->id().$self->selected_version()." with ".$media." media. Most likely the model did not grow.\n";
5093                    return undef;
5094            }
5095            #Clearing output
5096            $self->figmodel()->clearing_output($UniqueFilename,"Classify-".$self->id().$self->selected_version()."-".$UniqueFilename.".log");
5097            my $geneHash;
5098            my $activeGeneHash;
5099            for (my $i=0; $i < $ReactionTB->size(); $i++) {
5100                    my $Row = $ReactionTB->get_row($i);
5101                    if (defined($Row->{"Min FLUX"}) && defined($Row->{"Max FLUX"}) && defined($Row->{"DATABASE ID"}) && $Row->{"DATABASE ID"}->[0] =~ m/rxn\d\d\d\d\d/) {
5102                            my $data = $self->get_reaction_data($Row->{"DATABASE ID"}->[0]);
5103                            if (defined($data->{"ASSOCIATED PEG"})) {
5104                                    my $active = 0;
5105                                    if ($Row->{"Min FLUX"}->[0] > 0.00000001 || $Row->{"Max FLUX"}->[0] < -0.00000001 || ($Row->{"Max FLUX"}->[0]-$Row->{"Min FLUX"}->[0]) > 0.00000001) {
5106                                            $active = 1;
5107                                    }
5108                                    for (my $j=0; $j < @{$data->{"ASSOCIATED PEG"}}; $j++) {
5109                                            $_ = $data->{"ASSOCIATED PEG"}->[$j];
5110                                            my @OriginalArray = /(peg\.\d+)/g;
5111                                            for (my $k=0; $k < @OriginalArray; $k++) {
5112                                                    if ($active == 1) {
5113                                                            $activeGeneHash->{$OriginalArray[$k]} = 1;
5114                                                    }
5115                                                    $geneHash->{$OriginalArray[$k]} = 1;
5116                                            }
5117                                    }
5118                            }
5119                    }
5120            }
5121            my @allGenes = keys(%{$geneHash});
5122            for (my $i=0; $i < @allGenes; $i++) {
5123                    if (!defined($activeGeneHash->{$allGenes[$i]})) {
5124                            push(@{$output},$allGenes[$i]);
5125                    }
5126            }
5127            if (defined($output)) {
5128                    if (defined($save) && $save == 1) {
5129                            my $tbl = $self->load_model_table("InactiveGenes");
5130                            my $row = $tbl->get_table_by_key("MEDIA",$media)->get_row_by_key("MAXGROWTH",$maxGrowth);
5131                            if (defined($row)) {
5132                                    $row->{GENES} = $output;
5133                            } else {
5134                                    $tbl->add_row({GENES => $output,MEDIA => [$media],MAXGROWTH => [$maxGrowth]});
5135                            }
5136                            $tbl->save();
5137                    }
5138            }
5139            return $output;
5140    }
5141    
5142    sub ConvertVersionsToHistoryFile {
5143            my ($self) = @_;
5144            my $vone = 0;
5145            my $vtwo = 0;
5146            my $continue = 1;
5147            my $lastTable;
5148            my $currentTable;
5149            my $cause;
5150            my $lastChanged = 0;
5151            my $noHitCount = 0;
5152            while ($continue == 1) {
5153                    $cause = "NONE";
5154                    $currentTable = undef;
5155                    if (-e $self->directory().$self->id()."V".($vone+1).".".$vtwo.".txt") {
5156                            $noHitCount = 0;
5157                            $lastChanged = 0;
5158                            $vone = $vone+1;
5159                            $currentTable = $self->figmodel()->database()->load_table($self->directory().$self->id()."V".$vone.".".$vtwo.".txt",";","|",1,["LOAD","DIRECTIONALITY","COMPARTMENT","ASSOCIATED PEG"]);
5160                            $cause = "RECONSTRUCTION";
5161                    } elsif (-e $self->directory().$self->id()."V".$vone.".".($vtwo+1).".txt") {
5162                            $noHitCount = 0;
5163                            $lastChanged = 0;
5164                            $vtwo = $vtwo+1;
5165                            $currentTable = $self->figmodel()->database()->load_table($self->directory().$self->id()."V".$vone.".".$vtwo.".txt",";","|",1,["LOAD","DIRECTIONALITY","COMPARTMENT","ASSOCIATED PEG"]);
5166                            $cause = "AUTOCOMPLETION";
5167                    } elsif ($lastChanged == 0) {
5168                            $lastChanged = 1;
5169                            $vone = $vone+1;
5170                            $cause = "RECONSTRUCTION";
5171                    } elsif ($lastChanged == 1) {
5172                            $lastChanged = 2;
5173                            $vone = $vone-1;
5174                            $vtwo = $vtwo+1;
5175                            $cause = "AUTOCOMPLETION";
5176                    } elsif ($lastChanged == 2) {
5177                            $lastChanged = 0;
5178                            $vone = $vone+1;
5179                            $cause = "RECONSTRUCTION";
5180                    }
5181                    if (defined($currentTable)) {
5182                            if (defined($lastTable)) {
5183                                    print $cause."\t".$self->directory().$self->id()."V".$vone.".".$vtwo.".txt\n";
5184                                    $self->calculate_model_changes($lastTable,$cause,$currentTable,"V".$vone.".".$vtwo);
5185                            }
5186                            $lastTable = $currentTable;
5187                    } else {
5188                            $noHitCount++;
5189                            if ($noHitCount >= 40) {
5190                                    last;
5191                            }
5192                    }
5193            }
5194    }
5195    
5196  1;  1;

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

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3