[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.2, Fri Dec 11 21:37:02 2009 UTC revision 1.13, Mon May 10 21:45:44 2010 UTC
# Line 1  Line 1 
 package FIGMODELmodel;  
1  use strict;  use strict;
2    package FIGMODELmodel;
3    
4  =head1 FIGMODELmodel object  =head1 FIGMODELmodel object
5  =head2 Introduction  =head2 Introduction
# Line 14  Line 14 
14  =cut  =cut
15  sub new {  sub new {
16          my ($class,$figmodel,$id) = @_;          my ($class,$figmodel,$id) = @_;
17    
18          #Error checking first          #Error checking first
19          if (!defined($figmodel)) {          if (!defined($figmodel)) {
20                  print STDERR "FIGMODELmodel->new(undef,".$id."):figmodel must be defined to create a model object!\n";                  print STDERR "FIGMODELmodel->new(undef,".$id."):figmodel must be defined to create a model object!\n";
# Line 39  Line 40 
40                  $self->{_data} = $tbl->get_row($id);                  $self->{_data} = $tbl->get_row($id);
41          } else {          } else {
42                  $self->{_data} = $tbl->get_row_by_key($id,"id");                  $self->{_data} = $tbl->get_row_by_key($id,"id");
43                  if (defined($self->{_data})) {                  if (!defined($self->{_data})) {
44                          $index = $tbl->row_index($self->{_data});                          if ($id =~ m/(.+)(V[^V]+)/) {
45                                    $self->{_data} = $tbl->get_row_by_key($1,"id");
46                                    if (!defined($self->{_data})) {
47                                            $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");
48                                            return undef;
49                                    }
50                                    $self->{_selectedversion} = $2;
51                            } else {
52                                    $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find model ".$id." in database!");
53                                    return undef;
54                  }                  }
55          }          }
56                    $index = $tbl->row_index($self->{_data});
57            }
58          if (!defined($self->{_data})) {          if (!defined($self->{_data})) {
59                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find specified id in database!");                  $self->figmodel()->error_message("FIGMODELmodel->new(figmodel,".$id."):could not find specified id in database!");
60                  return undef;                  return undef;
# Line 50  Line 62 
62          $self->{_index} = $index;          $self->{_index} = $index;
63          $self->figmodel()->{_models}->{$self->id()} = $self;          $self->figmodel()->{_models}->{$self->id()} = $self;
64          $self->figmodel()->{_models}->{$self->index()} = $self;          $self->figmodel()->{_models}->{$self->index()} = $self;
   
65          return $self;          return $self;
66  }  }
67    
# Line 119  Line 130 
130          return $self->{"_fig"};          return $self->{"_fig"};
131  }  }
132    
133    =head3 aquireModelLock
134    
135    Definition:
136    
137            FIGMODELmodel->aquireModelLock();
138    
139    Description:
140    
141            Locks the database for alterations relating to the current model object
142    
143    =cut
144    sub aquireModelLock {
145            my ($self) = @_;
146            $self->figmodel()->database()->genericLock($self->id());
147    }
148    
149    =head3 releaseModelLock
150    
151    Definition:
152    
153            FIGMODELmodel->releaseModelLock();
154    
155    Description:
156    
157            Unlocks the database for alterations relating to the current model object
158    
159    =cut
160    sub releaseModelLock {
161            my ($self) = @_;
162            $self->figmodel()->database()->genericUnlock($self->id());
163    }
164    
165  =head3 mgdata  =head3 mgdata
166  Definition:  Definition:
167          FIGMODEL = FIGMODELmodel->mgdata();          FIGMODEL = FIGMODELmodel->mgdata();
# Line 230  Line 273 
273                  my $ClassRow = $self->{_reaction_classes}->get_row_by_key($reaction,"REACTION");                  my $ClassRow = $self->{_reaction_classes}->get_row_by_key($reaction,"REACTION");
274                  if (defined($ClassRow) && defined($ClassRow->{CLASS})) {                  if (defined($ClassRow) && defined($ClassRow->{CLASS})) {
275                          my $class;                          my $class;
276                            my $min = $ClassRow->{MIN}->[0];
277                            my $max = $ClassRow->{MAX}->[0];
278                          if ($ClassRow->{CLASS}->[0] eq "Positive") {                          if ($ClassRow->{CLASS}->[0] eq "Positive") {
279                                  $class = "Essential =>";                                  $class = "Essential =>";
280                                    $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
281                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative") {
282                                  $class = "Essential <=";                                  $class = "Essential <=";
283                                    $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
284                          } elsif ($ClassRow->{CLASS}->[0] eq "Positive variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Positive variable") {
285                                  $class = "Active =>";                                  $class = "Active =>";
286                                    $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
287                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Negative variable") {
288                                  $class = "Active <=";                                  $class = "Active <=";
289                                    $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
290                          } elsif ($ClassRow->{CLASS}->[0] eq "Variable") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Variable") {
291                                  $class = "Active <=>";                                  $class = "Active <=>";
292                                    $class.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
293                          } elsif ($ClassRow->{CLASS}->[0] eq "Blocked") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Blocked") {
294                                  $class = "Inactive";                                  $class = "Inactive";
295                          } elsif ($ClassRow->{CLASS}->[0] eq "Dead") {                          } elsif ($ClassRow->{CLASS}->[0] eq "Dead") {
296                                  $class = "Disconnected";                                  $class = "Disconnected";
297                          }                          }
298    
299                          if (!defined($nohtml) || $nohtml ne "1") {                          if (!defined($nohtml) || $nohtml ne "1") {
300                                  $class = "<span title=\"Flux:".$ClassRow->{MIN}->[0]." to ".$ClassRow->{MAX}->[0]."\">".$class."</span>";                                  $class = "<span title=\"Flux:".$min." to ".$max."\">".$class."</span>";
301                          }                          }
302    
303                          return $class;                          return $class;
304                  }                  }
305                  return undef;                  return undef;
# Line 268  Line 320 
320                                  $classstring .= "<br>";                                  $classstring .= "<br>";
321                          }                          }
322                          my $NewClass;                          my $NewClass;
323                            my $min = $ClassRow->{MIN}->[$i];
324                            my $max = $ClassRow->{MAX}->[$i];
325                          if ($ClassRow->{CLASS}->[$i] eq "Positive") {                          if ($ClassRow->{CLASS}->[$i] eq "Positive") {
326                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential =>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential =>";
327                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
328                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative") {
329                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential <=";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Essential <=";
330                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
331                          } elsif ($ClassRow->{CLASS}->[$i] eq "Positive variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Positive variable") {
332                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active =>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active =>";
333                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
334                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Negative variable") {
335                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=";
336                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
337                          } elsif ($ClassRow->{CLASS}->[$i] eq "Variable") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Variable") {
338                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=>";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Active <=>";
339                                  if (!defined($nohtml) || $nohtml ne "1") {                                  $NewClass.="<br>[Flux: ".sprintf("%.3g",$min)." to ".sprintf("%.3g",$max)."]<br>";
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
340                          } elsif ($ClassRow->{CLASS}->[$i] eq "Blocked") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Blocked") {
341                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Inactive";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Inactive";
                                 if (!defined($nohtml) || $nohtml ne "1") {  
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
                                 }  
342                          } elsif ($ClassRow->{CLASS}->[$i] eq "Dead") {                          } elsif ($ClassRow->{CLASS}->[$i] eq "Dead") {
343                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Disconnected";                                  $NewClass = $ClassRow->{MEDIA}->[$i].":Disconnected";
                                 if (!defined($nohtml) || $nohtml ne "1") {  
                                         $NewClass = "<span title=\"Flux:".$ClassRow->{MIN}->[$i]." to ".$ClassRow->{MAX}->[$i]."\">".$NewClass."</span>";  
344                                  }                                  }
345    
346                            if (!defined($nohtml) || $nohtml ne "1") {
347                                    $NewClass = "<span title=\"Flux:".$min." to ".$max."\">".$NewClass."</span>";
348                          }                          }
349                          $classstring .= $NewClass;                          $classstring .= $NewClass;
350                  }                  }
# Line 366  Line 408 
408          return $Data->{LOAD}->[0];          return $Data->{LOAD}->[0];
409  }  }
410    
411    =head3 load_model_table
412    
413    Definition: FIGMODELTable = FIGMODELmodel->load_model_table(string:table name,0/1:refresh the table));
414    
415    Description: Returns the table specified by the input filename. Table will be stored in a file in the model directory.
416    
417    =cut
418    sub load_model_table {
419            my ($self,$name,$refresh) = @_;
420            if (!defined($refresh)) {
421                    $refresh = 1;
422            }
423            if ($refresh == 1) {
424                    delete $self->{"_".$name};
425            }
426            if (!defined($self->{"_".$name})) {
427                    my $tbldef = $self->figmodel()->config("$name");
428                    if (!defined($tbldef)) {
429                            return undef;
430                    }
431                    my $filename = $self->directory().$name."-".$self->id().$self->selected_version().".tbl";
432                    $self->{"_".$name} = $self->figmodel()->database()->load_table($filename,"\t","|",$tbldef->{headingline}->[0],$tbldef->{hashcolumns});
433                    if (!defined($self->{"_".$name})) {
434                            if (defined($tbldef->{prefix})) {
435                                    $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},"\t","|",join(@{$tbldef->{prefix}},"\n"));
436                            } else {
437                                    $self->{"_".$name} = FIGMODELTable->new($tbldef->{columns},$filename,$tbldef->{hashcolumns},"\t","|");
438                            }
439                    }
440            }
441            return $self->{"_".$name};
442    }
443    
444  =head3 get_reaction_number  =head3 get_reaction_number
445  Definition:  Definition:
446          int = FIGMODELmodel->get_reaction_number();          int = FIGMODELmodel->get_reaction_number();
# Line 393  Line 468 
468    
469          if (!defined($self->{_reaction_data})) {          if (!defined($self->{_reaction_data})) {
470                  $self->{_reaction_data} = $self->figmodel()->database()->GetDBModel($self->id());                  $self->{_reaction_data} = $self->figmodel()->database()->GetDBModel($self->id());
471                    my $classTbl = $self->reaction_class_table();
472                    for (my $i=0; $i < $classTbl->size(); $i++) {
473                            my $row = $classTbl->get_row($i);
474                            my $rxnRow = $self->{_reaction_data}->get_row_by_key($row->{"REACTION"}->[0],"LOAD");
475                            for (my $j=0; $j < @{$row->{MEDIA}};$j++) {
476                                    my $class = "Active <=>";
477                                    if ($row->{CLASS}->[$j] eq "Positive") {
478                                            $class = "Essential =>";
479                                    } elsif ($row->{CLASS}->[$j] eq "Negative") {
480                                            $class = "Essential <=";
481                                    } elsif ($row->{CLASS}->[$j] eq "Blocked") {
482                                            $class = "Inactive";
483                                    } elsif ($row->{CLASS}->[$j] eq "Positive variable") {
484                                            $class = "Active =>";
485                                    } elsif ($row->{CLASS}->[$j] eq "Negative variable") {
486                                            $class = "Active <=";
487                                    } elsif ($row->{CLASS}->[$j] eq "Variable") {
488                                            $class = "Active <=>";
489                                    } elsif ($row->{CLASS}->[$j] eq "Dead") {
490                                            $class = "Dead";
491                                    }
492                                    push(@{$rxnRow->{PREDICTIONS}},$row->{MEDIA}->[$j].":".$class);
493                            }
494                    }
495          }          }
496    
497          return $self->{_reaction_data};          return $self->{_reaction_data};
498  }  }
499    
500    =head3 feature_table
501    Definition:
502            FIGMODELTable = FIGMODELmodel->feature_table();
503    Description:
504            Returns FIGMODELTable with the feature list for the model
505    =cut
506    sub feature_table {
507            my ($self) = @_;
508    
509            if (!defined($self->{_feature_data})) {
510                    #Getting the genome feature list
511                    my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
512                    if (!defined($FeatureTable)) {
513                            print STDERR "FIGMODELmodel:feature_table:Could not get features for genome ".$self->genome()." in database!";
514                            return undef;
515                    }
516                    #Getting the reaction table for the model
517                    my $rxnTable = $self->reaction_table();
518                    if (!defined($rxnTable)) {
519                    print STDERR "FIGMODELmodel:feature_table:Could not get reaction table for model ".$self->id()." in database!";
520                            return undef;
521                }
522                    #Cloning the feature table
523                    $self->{_feature_data} = $FeatureTable->clone_table_def();
524                    $self->{_feature_data}->add_headings(($self->id()."REACTIONS",$self->id()."PREDICTIONS"));
525                for (my $i=0; $i < $rxnTable->size(); $i++) {
526                    my $Row = $rxnTable->get_row($i);
527                    if (defined($Row) && defined($Row->{"ASSOCIATED PEG"})) {
528                            foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {
529                                    my $temp = $GeneSet;
530                                    $temp =~ s/\+/|/g;
531                                    $temp =~ s/\sAND\s/|/gi;
532                                    $temp =~ s/\sOR\s/|/gi;
533                                    $temp =~ s/[\(\)\s]//g;
534                                    my @GeneList = split(/\|/,$temp);
535                                    foreach my $Gene (@GeneList) {
536                                    my $FeatureRow = $self->{_feature_data}->get_row_by_key("fig|".$self->genome().".".$Gene,"ID");
537                                                    if (!defined($FeatureRow)) {
538                                                            $FeatureRow = $FeatureTable->get_row_by_key("fig|".$self->genome().".".$Gene,"ID");
539                                                            if (defined($FeatureRow)) {
540                                                                    $self->{_feature_data}->add_row($FeatureRow);
541                                                            }
542                                                    }
543                                                    if (defined($FeatureRow)) {
544                                                            $self->{_feature_data}->add_data($FeatureRow,$self->id()."REACTIONS",$Row->{"LOAD"}->[0],1);
545                                                    }
546                                    }
547                            }
548                    }
549                }
550                #Loading predictions
551                my @files = glob($self->directory()."EssentialGenes-".$self->id()."-*");
552                foreach my $file (@files) {
553                    if ($file =~ m/\-([^\-]+)\.tbl/) {
554                            my $media = $1;
555                            my $list = $self->figmodel()->database()->load_single_column_file($file,"");
556                            my $hash;
557                            foreach my $gene (@{$list}) {
558                                    $hash->{$gene} = 1;
559                            }
560                            for (my $i=0; $i < $self->{_feature_data}->size(); $i++) {
561                                    my $Row = $self->{_feature_data}->get_row($i);
562                                    if ($Row->{ID}->[0] =~ m/(peg\.\d+)/) {
563                                            my $gene = $1;
564                                            if (defined($hash->{$gene})) {
565                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":essential");
566                                            } else {
567                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":nonessential");
568                                            }
569                                    }
570                            }
571                    }
572                }
573            }
574            return $self->{_feature_data};
575    }
576    
577  =head3 reaction_class_table  =head3 reaction_class_table
578  Definition:  Definition:
579          FIGMODELTable = FIGMODELmodel->reaction_class_table();          FIGMODELTable = FIGMODELmodel->reaction_class_table();
# Line 438  Line 614 
614          return $self->{_compound_class_table};          return $self->{_compound_class_table};
615  }  }
616    
617    =head3 get_essential_genes
618    Definition:
619            [string::peg ID] = FIGMODELmodel->get_essential_genes(string::media condition);
620    Description:
621            Returns an reference to an array of the predicted essential genes during growth in the input media condition
622    =cut
623    sub get_essential_genes {
624            my ($self,$media) = @_;
625    
626            if (!defined($media)) {
627                    $media = "Complete";
628            }
629            if (!defined($self->{_essential_genes}->{$media})) {
630                    $self->{_essential_genes}->{$media} = undef;
631                    if (-e $self->directory()."EssentialGenes-".$self->id().$self->selected_version()."-".$media.".tbl") {
632                            $self->{_essential_genes}->{$media} = $self->figmodel()->database()->load_single_column_file($self->directory()."EssentialGenes-".$self->id().$self->selected_version()."-".$media.".tbl","");
633                    }
634            }
635    
636            return $self->{_essential_genes}->{$media};
637    }
638    
639  =head3 compound_table  =head3 compound_table
640  Definition:  Definition:
641          FIGMODELTable = FIGMODELmodel->compound_table();          FIGMODELTable = FIGMODELmodel->compound_table();
# Line 456  Line 654 
654    
655  =head3 get_compound_data  =head3 get_compound_data
656  Definition:  Definition:
657          string = FIGMODELmodel->get_compound_data(string::compound ID);          {string:key=>[string]:values} = FIGMODELmodel->get_compound_data(string::compound ID);
658  Description:  Description:
659          Returns model compound data          Returns model compound data
660  =cut  =cut
# Line 467  Line 665 
665                  return undef;                  return undef;
666          }          }
667          if ($compound =~ m/^\d+$/) {          if ($compound =~ m/^\d+$/) {
668                  $self->compound_table()->get_row($compound);                  return $self->compound_table()->get_row($compound);
669          }          }
670          return $self->compound_table()->get_row_by_key($compound,"DATABASE");          return $self->compound_table()->get_row_by_key($compound,"DATABASE");
671  }  }
672    
673    =head3 get_feature_data
674    Definition:
675            {string:key=>[string]:values} = FIGMODELmodel->get_feature_data(string::feature ID);
676    Description:
677            Returns model feature data
678    =cut
679    sub get_feature_data {
680            my ($self,$feature) = @_;
681            if (!defined($self->feature_table())) {
682                    return undef;
683            }
684            if ($feature =~ m/^\d+$/) {
685                    return $self->feature_table()->get_row($feature);
686            }
687            if ($feature =~ m/(peg\.\d+)/) {
688                    $feature = $1;
689            }
690            return $self->feature_table()->get_row_by_key("fig|".$self->genome().".".$feature,"ID");
691    }
692    
693  =head3 genome  =head3 genome
694  Definition:  Definition:
695          string = FIGMODELmodel->genome();          string = FIGMODELmodel->genome();
# Line 681  Line 899 
899                                  $self->{_modification_time} = $stats->{"Gap fill date"}->[0];                                  $self->{_modification_time} = $stats->{"Gap fill date"}->[0];
900                          }                          }
901                  } else {                  } else {
902                          $self->{_modification_time} = 0;                          $self->{_modification_time} = $self->{_data}->{date}->[0];
903                  }                  }
904          }          }
905          return $self->{_modification_time};          return $self->{_modification_time};
# Line 892  Line 1110 
1110          #Checking that the table is defined and the output file exists          #Checking that the table is defined and the output file exists
1111          if (defined($result) && defined($result->get_row(0)->{"ESSENTIALGENES"})) {          if (defined($result) && defined($result->get_row(0)->{"ESSENTIALGENES"})) {
1112                  $self->figmodel()->database()->print_array_to_file($self->directory()."EssentialGenes-".$self->id()."-".$Media.".tbl",[join("\n",@{$result->get_row(0)->{"ESSENTIALGENES"}})]);                  $self->figmodel()->database()->print_array_to_file($self->directory()."EssentialGenes-".$self->id()."-".$Media.".tbl",[join("\n",@{$result->get_row(0)->{"ESSENTIALGENES"}})]);
1113            } else {
1114                    $self->figmodel()->error_message("FIGMODELmodel:run_default_model_predictions:could not identify essential reactions for model ".$self->id().$self->selected_version().".");
1115                    return $self->figmodel()->fail();
1116          }          }
1117    
1118          #Classifying reactions and compounds          #Classifying reactions and compounds
1119          my $tbl = $self->classify_model_reactions($Media);          my $tbl = $self->classify_model_reactions($Media);
1120            if (!defined($tbl)) {
1121                    $self->figmodel()->error_message("FIGMODELmodel:run_default_model_predictions:could not classify reactions for model ".$self->id().$self->selected_version().".");
1122                    return $self->figmodel()->fail();
1123            }
1124          $tbl->save();          $tbl->save();
1125    
1126          return $self->figmodel()->success();          return $self->figmodel()->success();
# Line 1049  Line 1274 
1274                                  $CurrentStats->{"Gap filling reactions"}->[0]++;                                  $CurrentStats->{"Gap filling reactions"}->[0]++;
1275                          } else {                          } else {
1276                                  foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {                                  foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {
1277                                          my @GeneList = split(/\+/,$GeneSet);                                          $_ = $GeneSet;
1278                                            my @GeneList = /(peg\.\d+)/g;
1279                                          foreach my $Gene (@GeneList) {                                          foreach my $Gene (@GeneList) {
1280                                                  if ($Gene =~ m/(peg\.\d+)/) {                                                  if ($Gene =~ m/(peg\.\d+)/) {
1281                                                          $GeneHash{$1} = 1;                                                          $GeneHash{$1} = 1;
# Line 1119  Line 1345 
1345                          }                          }
1346                  }                  }
1347                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1348                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$UniqueFilename."TestMedia",["GapFilling"],{"Default max drain flux" => 0},"GapFill".$self->id().".log",undef));                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),$UniqueFilename."TestMedia",["GapFilling"],{"Default max drain flux" => 0,"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0]},"GapFill".$self->id().".log",undef));
1349                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1350          } else {          } else {
1351                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),undef,["GapFilling"],undef,"GapFill".$self->id().".log",undef));                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),undef,["GapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0]},"GapFill".$self->id().".log",undef));
1352          }          }
1353    
1354          #Parse the solutions file for the model and get the reaction list from it          #Parse the solutions file for the model and get the reaction list from it
# Line 1140  Line 1366 
1366          for (my $i=($SolutionData->size()-1); $i >=0; $i--) {          for (my $i=($SolutionData->size()-1); $i >=0; $i--) {
1367                  if (defined($SolutionData->get_row($i)->{"Notes"}) && $SolutionData->get_row($i)->{"Notes"}->[0] =~ m/^Recursive/) {                  if (defined($SolutionData->get_row($i)->{"Notes"}) && $SolutionData->get_row($i)->{"Notes"}->[0] =~ m/^Recursive/) {
1368                          my $AllSolutions = substr($SolutionData->get_row($i)->{"Notes"}->[0],15);                          my $AllSolutions = substr($SolutionData->get_row($i)->{"Notes"}->[0],15);
                         print "Solution:".$AllSolutions."\n";  
1369                          my @TempThree = split(/\|/,$AllSolutions);                          my @TempThree = split(/\|/,$AllSolutions);
1370                          if (@TempThree > 0 && $TempThree[0] =~ m/.+:(.+)/) {                          if (@TempThree > 0 && $TempThree[0] =~ m/.+:(.+)/) {
1371                                  my @TempFour = split(/,/,$1);                                  my @TempFour = split(/,/,$1);
# Line 1163  Line 1388 
1388                                                  push(@{$ReactionList},$ID);                                                  push(@{$ReactionList},$ID);
1389                                          }                                          }
1390                                  }                                  }
                                 print "Solution:".$TempThree[0]."\n";  
1391                                  $self->figmodel()->IntegrateGrowMatchSolution($self->id(),undef,$ReactionList,$DirectionList,"GAP FILLING",0,1);                                  $self->figmodel()->IntegrateGrowMatchSolution($self->id(),undef,$ReactionList,$DirectionList,"GAP FILLING",0,1);
1392                          }                          }
1393                          last;                          last;
# Line 1171  Line 1395 
1395          }          }
1396          #Updating model stats with gap filling results          #Updating model stats with gap filling results
1397          my $ElapsedTime = time() - $StartTime;          my $ElapsedTime = time() - $StartTime;
1398          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
1399          #Determining why each gap filling reaction was added          #Determining why each gap filling reaction was added
1400          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);
1401          if (!defined($donotclear) || $donotclear != 1) {          if (!defined($donotclear) || $donotclear != 1) {
# Line 1191  Line 1415 
1415          return $self->success();          return $self->success();
1416  }  }
1417    
1418    =head3 GapGenModel
1419    Definition:
1420            FIGMODELmodel->GapGenModel();
1421    Description:
1422            Runs the gap generation algorithm to correct a single false positive prediction. Results are loaded into a table.
1423    =cut
1424    
1425    sub GapGenModel {
1426            my ($self,$Media,$KOList,$NoKOList,$Experiment,$SolutionLimit) = @_;
1427    
1428            #Enforcing nonoptional arguments
1429            if (!defined($Media)) {
1430                    return undef;
1431            }
1432            if (!defined($KOList)) {
1433                    $KOList->[0] = "none";
1434            }
1435            if (!defined($NoKOList)) {
1436                    $NoKOList->[0] = "none";
1437            }
1438            if (!defined($Experiment)) {
1439                    $Experiment= "ReactionKO";
1440            }
1441            if (!defined($SolutionLimit)) {
1442                    $SolutionLimit = "10";
1443            }
1444    
1445            #Translating the KO lists into arrays
1446            if (ref($KOList) ne "ARRAY") {
1447                    my $temp = $KOList;
1448                    $KOList = ();
1449                    push(@{$KOList},split(/[,;]/,$temp));
1450            }
1451            my $noKOHash;
1452            if (defined($NoKOList) && ref($NoKOList) ne "ARRAY") {
1453                    my $temp = $NoKOList;
1454                    $NoKOList = ();
1455                    push(@{$NoKOList},split(/[,;]/,$temp));
1456                    foreach my $rxn (@{$NoKOList}) {
1457                            $noKOHash->{$rxn} = 1;
1458                    }
1459            }
1460    
1461            #Checking if solutions exist for the input parameters
1462            $self->aquireModelLock();
1463            my $tbl = $self->load_model_table("GapGenSolutions");
1464            my $solutionRow = $tbl->get_table_by_key($Experiment,"Experiment")->get_table_by_key($Media,"Media")->get_row_by_key(join(",",@{$KOList}),"KOlist");
1465            my $solutions;
1466            if (defined($solutionRow)) {
1467                    #Checking if any solutions conform to the no KO list
1468                    foreach my $solution (@{$solutionRow->{Solutions}}) {
1469                            my @reactions = split(/,/,$solution);
1470                            my $include = 1;
1471                            foreach my $rxn (@reactions) {
1472                                    if ($rxn =~ m/(rxn\d\d\d\d\d)/) {
1473                                            if (defined($noKOHash->{$1})) {
1474                                                    $include = 0;
1475                                            }
1476                                    }
1477                            }
1478                            if ($include == 1) {
1479                                    push(@{$solutions},$solution);
1480                            }
1481                    }
1482            } else {
1483                    $solutionRow = {Media => [$Media],Experiment => [$Experiment],KOlist => [join(",",@{$KOList})]};
1484                    $tbl->add_row($solutionRow);
1485                    $self->figmodel()->database()->save_table($tbl);
1486            }
1487            $self->releaseModelLock();
1488    
1489            #Returning solution list of solutions were found
1490            if (defined($solutions) && @{$solutions} > 0) {
1491                    return $solutions;
1492            }
1493    
1494            #Getting unique filename
1495            my $Filename = $self->figmodel()->filename();
1496    
1497            #Running the gap generation
1498            system($self->figmodel()->GenerateMFAToolkitCommandLineCall($Filename,$self->id().$self->selected_version(),$Media,["GapGeneration"],{"Recursive MILP solution limit" => $SolutionLimit ,"Reactions that should always be active" => join(";",@{$NoKOList}),"Reactions to knockout" => join(";",@{$KOList}),"Reactions that are always blocked" => "none"},"Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log",undef,undef));
1499            my $ProblemReport = $self->figmodel()->LoadProblemReport($Filename);
1500            if (!defined($ProblemReport)) {
1501                    $self->figmodel()->error_message("FIGMODEL:GapGenerationAlgorithm;No problem report;".$Filename.";".$self->id().$self->selected_version().";".$Media.";".$KOList.";".$NoKOList);
1502                    return undef;
1503            }
1504    
1505            #Clearing the output folder and log file
1506            $self->figmodel()->clearing_output($Filename,"Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log");
1507    
1508            #Saving the solution
1509            $self->aquireModelLock();
1510            $tbl = $self->load_model_table("GapGenSolutions");
1511            $solutionRow = $tbl->get_table_by_key($Experiment,"Experiment")->get_table_by_key($Media,"Media")->get_row_by_key(join(",",@{$KOList}),"KOlist");
1512            for (my $j=0; $j < $ProblemReport->size(); $j++) {
1513                    if ($ProblemReport->get_row($j)->{"Notes"}->[0] =~ m/^Recursive\sMILP\s([^)]+)/) {
1514                            my @SolutionList = split(/\|/,$1);
1515                            for (my $k=0; $k < @SolutionList; $k++) {
1516                                    if ($SolutionList[$k] =~ m/(\d+):(.+)/) {
1517                                            push(@{$solutionRow->{Solutions}},$2);
1518                                            push(@{$solutions},$2);
1519                                    }
1520                            }
1521                    }
1522            }
1523            $self->figmodel()->database()->save_table($tbl);
1524            $self->releaseModelLock();
1525    
1526            return $solutions;
1527    }
1528    
1529  =head3 datagapfill  =head3 datagapfill
1530  Definition:  Definition:
1531          success()/fail() = FIGMODELmodel->datagapfill();          success()/fail() = FIGMODELmodel->datagapfill();
# Line 1201  Line 1536 
1536          my ($self,$GapFillingRunSpecs,$TansferFileSuffix) = @_;          my ($self,$GapFillingRunSpecs,$TansferFileSuffix) = @_;
1537          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
1538          if (defined($GapFillingRunSpecs) && @{$GapFillingRunSpecs} > 0) {          if (defined($GapFillingRunSpecs) && @{$GapFillingRunSpecs} > 0) {
                 print "Gap filling specs:\n".join("\n",@{$GapFillingRunSpecs})."\n\n";  
1539                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id().$self->selected_version(),"NoBounds",["DataGapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0],"Gap filling runs" => join(";",@{$GapFillingRunSpecs})},"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,undef));                  system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id().$self->selected_version(),"NoBounds",["DataGapFilling"],{"Reactions to knockout" => $self->config("permanently knocked out reactions")->[0],"Gap filling runs" => join(";",@{$GapFillingRunSpecs})},"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log",undef,undef));
   
1540                  #Checking that the solution exists                  #Checking that the solution exists
1541                  if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt") {                  if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt") {
1542                          $self->figmodel()->error_message("FIGMODEL:GapFillingAlgorithm: Could not find MFA output file!");                          $self->figmodel()->error_message("FIGMODEL:GapFillingAlgorithm: Could not find MFA output file!");
# Line 1213  Line 1546 
1546                  my $GapFillResultTable = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt",";","",0,undef);                  my $GapFillResultTable = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt",";","",0,undef);
1547                  if (defined($TansferFileSuffix)) {                  if (defined($TansferFileSuffix)) {
1548                          system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt ".$self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt");                          system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt ".$self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt");
                         system("cp ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingReport.txt ".$self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt");  
1549                  }                  }
   
1550                  #If the system is not configured to preserve all logfiles, then the mfatoolkit output folder is deleted                  #If the system is not configured to preserve all logfiles, then the mfatoolkit output folder is deleted
1551                  $self->figmodel()->clearing_output($UniqueFilename,"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log");                  $self->figmodel()->clearing_output($UniqueFilename,"GapFilling-".$self->id().$self->selected_version()."-".$UniqueFilename.".log");
1552                  return $GapFillingRunSpecs;                  return $GapFillResultTable;
1553          }          }
1554          if (defined($TansferFileSuffix)) {          if (defined($TansferFileSuffix)) {
1555                  $self->figmodel()->database()->print_array_to_file($self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt",["Experiment;Solution index;Solution cost;Solution reactions"]);                  $self->figmodel()->database()->print_array_to_file($self->directory().$self->id().$self->selected_version()."-".$TansferFileSuffix.".txt",["Experiment;Solution index;Solution cost;Solution reactions"]);
# Line 1284  Line 1615 
1615                          push(@{$DirectionArray},$SolutionHash{$ReactionList[$k]});                          push(@{$DirectionArray},$SolutionHash{$ReactionList[$k]});
1616                  }                  }
1617                  print "Integrating solution!\n";                  print "Integrating solution!\n";
1618                  $self->IntegrateGrowMatchSolution($self->id().$self->selected_version(),$self->directory().$self->id().$TempVersion.".txt",$ReactionArray,$DirectionArray,"Gapfilling ".$GapFillResultTable->get_row($i)->{"Experiment"}->[0],1,1);                  $self->figmodel()->IntegrateGrowMatchSolution($self->id().$self->selected_version(),$self->directory().$self->id().$TempVersion.".txt",$ReactionArray,$DirectionArray,"Gapfilling ".$GapFillResultTable->get_row($i)->{"Experiment"}->[0],1,1);
1619                  my $model = $self->get_model($self->id().$TempVersion);                  $self->PrintModelLPFile();
                 $model->PrintModelLPFile();  
1620                  #Running the model against all available experimental data                  #Running the model against all available experimental data
1621                  print "Running test model!\n";                  print "Running test model!\n";
1622                  my ($FalsePostives,$FalseNegatives,$CorrectNegatives,$CorrectPositives,$Errorvector,$HeadingVector) = $self->RunAllStudiesWithDataFast("All");                  my ($FalsePostives,$FalseNegatives,$CorrectNegatives,$CorrectPositives,$Errorvector,$HeadingVector) = $self->RunAllStudiesWithDataFast("All");
# Line 1367  Line 1697 
1697  sub CreateSingleGenomeReactionList {  sub CreateSingleGenomeReactionList {
1698          my ($self,$RunGapFilling) = @_;          my ($self,$RunGapFilling) = @_;
1699    
1700            #Creating directory
1701            if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/") {
1702                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/");
1703            } elsif ($self->owner() eq "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->genome()."/") {
1704                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->genome()."/");
1705            }
1706            if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/") {
1707                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/");
1708            }
1709    
1710          #Getting genome stats          #Getting genome stats
1711          my $genomestats = $self->figmodel()->get_genome_stats($self->genome());          my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
1712          my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());          my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
# Line 1601  Line 1941 
1941          }          }
1942    
1943          #Checking if a biomass reaction already exists          #Checking if a biomass reaction already exists
1944          my $BiomassReactionRow = $self->figmodel()->database()->get_row_by_key("BIOMASS TABLE",$self->id(),"MODELS");          my $BiomassReactionRow = $self->BuildSpecificBiomassReaction();
         if (!defined($BiomassReactionRow)) {  
                 $BiomassReactionRow = $self->BuildSpecificBiomassReaction();  
1945                  if (!defined($BiomassReactionRow)) {                  if (!defined($BiomassReactionRow)) {
1946                          $self->set_status(-2,"Preliminary reconstruction failed: could not generate biomass reaction");                          $self->set_status(-2,"Preliminary reconstruction failed: could not generate biomass reaction");
1947                          $self->figmodel()->error_message("FIGMODEL:CreateModelReactionList: Could not generate biomass function for ".$self->id()."!");                          $self->figmodel()->error_message("FIGMODEL:CreateModelReactionList: Could not generate biomass function for ".$self->id()."!");
1948                          return $self->fail();                          return $self->fail();
1949                  }                  }
         }  
1950          my $ReactionList = $BiomassReactionRow->{"ESSENTIAL REACTIONS"};          my $ReactionList = $BiomassReactionRow->{"ESSENTIAL REACTIONS"};
1951          push(@{$ReactionList},$BiomassReactionRow->{DATABASE}->[0]);          push(@{$ReactionList},$BiomassReactionRow->{DATABASE}->[0]);
1952    
# Line 1702  Line 2039 
2039          $self->figmodel()->database()->save_table($NewModelTable);          $self->figmodel()->database()->save_table($NewModelTable);
2040          $self->{_reaction_data} = $NewModelTable;          $self->{_reaction_data} = $NewModelTable;
2041          #Clearing the previous model from the cache          #Clearing the previous model from the cache
2042          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
2043          #Updating the model stats table          #Updating the model stats table
2044          $self->update_stats_for_build();          $self->update_stats_for_build();
2045          $self->PrintSBMLFile();          $self->PrintSBMLFile();
# Line 1823  Line 2160 
2160          }          }
2161    
2162          #Clearing the previous model from the cache          #Clearing the previous model from the cache
2163          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
2164          $ModelTable->save();          $ModelTable->save();
2165    
2166          return $self->success();          return $self->success();
# Line 1895  Line 2232 
2232          Runs microarray analysis attempting to turn off genes that are inactive in the microarray          Runs microarray analysis attempting to turn off genes that are inactive in the microarray
2233  =cut  =cut
2234  sub run_microarray_analysis {  sub run_microarray_analysis {
2235          my ($self,$media,$jobid,$index,$genecall) = @_;          my ($self,$media,$label,$index,$genecall) = @_;
2236          $genecall =~ s/_/:/g;          $genecall =~ s/_/:/g;
2237          $genecall =~ s/\//;/g;          $genecall =~ s/\//;/g;
2238          #print "\n\n".$genecall."\n\n";          my $uniqueFilename = $self->figmodel()->filename();
2239          my $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($jobid,$self->id(),$media,["MFA","MicroarrayAssertions"],{"Microarray assertions" => $self->id().";".$index.";".$genecall,"MFASolver" => "CPLEX","Network output location" => "/scratch/"},"MicroarrayAnalysis-".$jobid.".txt",undef,$self->selected_version());          my $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($uniqueFilename,$self->id(),$media,["ProductionMFA","ShewenellaExperiment"],{"Microarray assertions" => $label.";".$index.";".$genecall,"MFASolver" => "CPLEX","Network output location" => "/scratch/"},"MicroarrayAnalysis-".$uniqueFilename.".txt",undef,$self->selected_version());
         #print $command."\n";  
2240          system($command);          system($command);
2241          #system("/home/chenry/Software/MFAToolkitRepository/Linux/mfatoolkit resetparameter \"user bounds filename\" \"Carbon-D-Glucose.txt\" resetparameter output_folder \"32749.354149.0/\" resetparameter \"Microarray assertions\" \"Seed83333.1;0;peg.3130:-1;peg.4035:-1\" resetparameter \"MFASolver\" \"CPLEX\" resetparameter \"Network output location\" \"/scratch/\" LoadCentralSystem \"/vol/model-dev/MODEL_DEV_DB/Models/83333.1/Seed83333.1.txt\" > \"/vol/model-dev/MODEL_DEV_DB/ReactionDB/log/MicroarrayAnalysis-32749.354149.0.txt\"");          my $filename = $self->figmodel()->config("MFAToolkit output directory")->[0].$uniqueFilename."/MicroarrayOutput-".$index.".txt";
2242        if (-e $filename) {
2243            my $output = $self->figmodel()->database()->load_single_column_file($filename);
2244            if (defined($output->[0])) {
2245                    my @array = split(/;/,$output->[0]);
2246                    $self->figmodel()->clearing_output($uniqueFilename,"MicroarrayAnalysis-".$uniqueFilename.".txt");
2247                    return ($array[0],$array[1],$array[8].":".$array[2],$array[9].":".$array[3],$array[10].":".$array[4],$array[11].":".$array[5],$array[12].":".$array[6],$array[13].":".$array[7]);
2248            }
2249            print STDERR $filename." is empty!";
2250        }
2251        print STDERR $filename." not found!";
2252        $self->figmodel()->clearing_output($uniqueFilename,"MicroarrayAnalysis-".$uniqueFilename.".txt");
2253    
2254            return undef;
2255  }  }
2256    
2257  =head3 find_minimal_pathways  =head3 find_minimal_pathways
# Line 1912  Line 2261 
2261          Runs microarray analysis attempting to turn off genes that are inactive in the microarray          Runs microarray analysis attempting to turn off genes that are inactive in the microarray
2262  =cut  =cut
2263  sub find_minimal_pathways {  sub find_minimal_pathways {
2264          my ($self,$media,$objective,$solutionnum) = @_;          my ($self,$media,$objective,$solutionnum,$AllReversible,$additionalexchange) = @_;
2265    
2266          #Setting default media          #Setting default media
2267          if (!defined($media)) {          if (!defined($media)) {
# Line 1924  Line 2273 
2273                  $solutionnum = "5";                  $solutionnum = "5";
2274          }          }
2275    
2276            #Setting additional exchange fluxes
2277            if (!defined($additionalexchange) || length($additionalexchange) == 0) {
2278                    if ($self->id() eq "iAF1260") {
2279                            $additionalexchange = "cpd03422[c]:-100:100;cpd01997[c]:-100:100;cpd11416[c]:-100:0;cpd15378[c]:-100:0;cpd15486[c]:-100:0";
2280                    } else {
2281                            $additionalexchange = $self->figmodel()->config("default exchange fluxes")->[0];
2282                    }
2283            }
2284    
2285          #Translating objective          #Translating objective
2286          my $objectivestring;          my $objectivestring;
2287          if ($objective eq "ALL") {          if ($objective eq "ALL") {
# Line 1944  Line 2302 
2302                          }                          }
2303                  }                  }
2304                  for (my $i=0; $i < @objectives; $i++) {                  for (my $i=0; $i < @objectives; $i++) {
2305                          $self->find_minimal_pathways($media,$objectives[$i])                          $self->find_minimal_pathways($media,$objectives[$i]);
2306                  }                  }
2307                    return;
2308          } elsif ($objective eq "ENERGY") {          } elsif ($objective eq "ENERGY") {
2309                  $objectivestring = "MAX;FLUX;rxn00062;c;1";                  $objectivestring = "MAX;FLUX;rxn00062;c;1";
2310          } elsif ($objective =~ m/cpd\d\d\d\d\d/) {          } elsif ($objective =~ m/cpd\d\d\d\d\d/) {
2311                    if ($objective =~ m/\[(\w)\]/) {
2312                            $objectivestring = "MIN;DRAIN_FLUX;".$objective.";".$1.";1";
2313                            $additionalexchange .= ";".$objective."[".$1."]:-100:0";
2314                    } else {
2315                  $objectivestring = "MIN;DRAIN_FLUX;".$objective.";c;1";                  $objectivestring = "MIN;DRAIN_FLUX;".$objective.";c;1";
2316                            $additionalexchange .= ";".$objective."[c]:-100:0";
2317                    }
2318            } elsif ($objective =~ m/(rxn\d\d\d\d\d)/) {
2319                    my ($Reactants,$Products) = $self->figmodel()->GetReactionSubstrateData($objective);
2320                    for (my $i=0; $i < @{$Products};$i++) {
2321                            my $temp = $Products->[$i]->{"DATABASE"}->[0];
2322                            if ($additionalexchange !~ m/$temp/) {
2323                                    #$additionalexchange .= ";".$temp."[c]:-100:0";
2324                            }
2325                    }
2326                    for (my $i=0; $i < @{$Reactants};$i++) {
2327                            print $Reactants->[$i]->{"DATABASE"}->[0]." started\n";
2328                            $self->find_minimal_pathways($media,$Reactants->[$i]->{"DATABASE"}->[0],$additionalexchange);
2329                            print $Reactants->[$i]->{"DATABASE"}->[0]." done\n";
2330                    }
2331                    return;
2332            }
2333    
2334            #Adding additional drains
2335            if (($objective eq "cpd15665" || $objective eq "cpd15667" || $objective eq "cpd15668" || $objective eq "cpd15669") && $additionalexchange !~ m/cpd15666/) {
2336                    $additionalexchange .= ";cpd15666[c]:0:100";
2337            } elsif ($objective eq "cpd11493" && $additionalexchange !~ m/cpd12370/) {
2338                    $additionalexchange .= ";cpd12370[c]:0:100";
2339            } elsif ($objective eq "cpd00166" && $additionalexchange !~ m/cpd01997/) {
2340                    $additionalexchange .= ";cpd01997[c]:0:100;cpd03422[c]:0:100";
2341            }
2342    
2343            #Running MFAToolkit
2344            my $filename = $self->figmodel()->filename();
2345            my $command;
2346            if (defined($AllReversible) && $AllReversible == 1) {
2347                    $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($filename,$self->id(),$media,["ProductionMFA"],{"Make all reactions reversible in MFA"=>1, "Recursive MILP solution limit" => $solutionnum,"Generate pathways to objective" => 1,"MFASolver" => "CPLEX","objective" => $objectivestring,"exchange species" => $additionalexchange},"MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",undef,$self->selected_version());
2348            } else {
2349                    $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($filename,$self->id(),$media,["ProductionMFA"],{"Make all reactions reversible in MFA"=>0, "Recursive MILP solution limit" => $solutionnum,"Generate pathways to objective" => 1,"MFASolver" => "CPLEX","objective" => $objectivestring,"exchange species" => $additionalexchange},"MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",undef,$self->selected_version());
2350            }
2351            system($command);
2352    
2353            #Loading problem report
2354            my $results = $self->figmodel()->LoadProblemReport($filename);
2355            #Clearing output
2356            $self->figmodel()->clearing_output($filename,"MinimalPathways-".$media."-".$self->id()."-".$objective.".txt");
2357            if (!defined($results)) {
2358                    print STDERR $objective." pathway results not found!\n";
2359                    return;
2360            }
2361    
2362            #Parsing output
2363            my @Array;
2364            my $row = $results->get_row(1);
2365            if (defined($row->{"Notes"}->[0])) {
2366                    $_ = $row->{"Notes"}->[0];
2367                    @Array = /\d+:([^\|]+)\|/g;
2368            }
2369    
2370            #Writing output to file
2371            $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join("|",@Array)]);
2372    }
2373    
2374    =head3 find_minimal_pathways
2375    Definition:
2376            int::status = FIGMODEL->find_minimal_pathways(string::media,string::objective);
2377    Description:
2378            Runs microarray analysis attempting to turn off genes that are inactive in the microarray
2379    =cut
2380    sub find_minimal_pathways_two {
2381            my ($self,$media,$objective,$solutionnum,$AllReversible,$additionalexchange) = @_;
2382    
2383            #Setting default media
2384            if (!defined($media)) {
2385                    $media = "Complete";
2386            }
2387    
2388            #Setting default solution number
2389            if (!defined($solutionnum)) {
2390                    $solutionnum = "5";
2391          }          }
2392    
2393          #Setting additional exchange fluxes          #Setting additional exchange fluxes
2394          my $additionalexchange = $self->config("default exchange fluxes")->[0];          if (!defined($additionalexchange) || length($additionalexchange) == 0) {
2395          if ($objective eq "cpd15665" || $objective eq "cpd15667" || $objective eq "cpd15668" || $objective eq "cpd15669") {                  if ($self->id() eq "iAF1260") {
2396                            $additionalexchange = "cpd03422[c]:-100:100;cpd01997[c]:-100:100;cpd11416[c]:-100:0;cpd15378[c]:-100:0;cpd15486[c]:-100:0";
2397                    } else {
2398                            $additionalexchange = $self->figmodel()->config("default exchange fluxes")->[0];
2399                    }
2400            }
2401    
2402            #Translating objective
2403            my $objectivestring;
2404            if ($objective eq "ALL") {
2405                    #Getting the list of universal building blocks
2406                    my $buildingblocks = $self->config("universal building blocks");
2407                    my @objectives = keys(%{$buildingblocks});
2408                    #Getting the nonuniversal building blocks
2409                    my $otherbuildingblocks = $self->config("nonuniversal building blocks");
2410                    my @array = keys(%{$otherbuildingblocks});
2411                    if (defined($self->get_biomass()) && defined($self->figmodel()->get_reaction($self->get_biomass()->{"LOAD"}->[0]))) {
2412                            my $equation = $self->figmodel()->get_reaction($self->get_biomass()->{"LOAD"}->[0])->{"EQUATION"}->[0];
2413                            if (defined($equation)) {
2414                                    for (my $i=0; $i < @array; $i++) {
2415                                            if (CORE::index($equation,$array[$i]) > 0) {
2416                                                    push(@objectives,$array[$i]);
2417                                            }
2418                                    }
2419                            }
2420                    }
2421                    for (my $i=0; $i < @objectives; $i++) {
2422                            $self->find_minimal_pathways($media,$objectives[$i]);
2423                    }
2424                    return;
2425            } elsif ($objective eq "ENERGY") {
2426                    $objectivestring = "MAX;FLUX;rxn00062;c;1";
2427            } elsif ($objective =~ m/cpd\d\d\d\d\d/) {
2428                    if ($objective =~ m/\[(\w)\]/) {
2429                            $objectivestring = "MIN;DRAIN_FLUX;".$objective.";".$1.";1";
2430                            $additionalexchange .= ";".$objective."[".$1."]:-100:0";
2431                    } else {
2432                            $objectivestring = "MIN;DRAIN_FLUX;".$objective.";c;1";
2433                            $additionalexchange .= ";".$objective."[c]:-100:0";
2434                    }
2435            } elsif ($objective =~ m/(rxn\d\d\d\d\d)/) {
2436                    my ($Reactants,$Products) = $self->figmodel()->GetReactionSubstrateData($objective);
2437                    for (my $i=0; $i < @{$Products};$i++) {
2438                            my $temp = $Products->[$i]->{"DATABASE"}->[0];
2439                            if ($additionalexchange !~ m/$temp/) {
2440                                    #$additionalexchange .= ";".$temp."[c]:-100:0";
2441                            }
2442                    }
2443                    for (my $i=0; $i < @{$Reactants};$i++) {
2444                            print $Reactants->[$i]->{"DATABASE"}->[0]." started\n";
2445                            $self->find_minimal_pathways($media,$Reactants->[$i]->{"DATABASE"}->[0],$additionalexchange);
2446                            print $Reactants->[$i]->{"DATABASE"}->[0]." done\n";
2447                    }
2448                    return;
2449            }
2450    
2451            #Adding additional drains
2452            if (($objective eq "cpd15665" || $objective eq "cpd15667" || $objective eq "cpd15668" || $objective eq "cpd15669") && $additionalexchange !~ m/cpd15666/) {
2453                  $additionalexchange .= ";cpd15666[c]:0:100";                  $additionalexchange .= ";cpd15666[c]:0:100";
2454          } elsif ($objective eq "cpd11493") {          } elsif ($objective eq "cpd11493" && $additionalexchange !~ m/cpd12370/) {
2455                  $additionalexchange .= ";cpd12370[c]:0:100";                  $additionalexchange .= ";cpd12370[c]:0:100";
2456          } elsif ($objective eq "cpd00166") {          } elsif ($objective eq "cpd00166" && $additionalexchange !~ m/cpd01997/) {
2457                  $additionalexchange .= ";cpd01997[c]:0:100;cpd03422[c]:0:100";                  $additionalexchange .= ";cpd01997[c]:0:100;cpd03422[c]:0:100";
2458          }          }
2459    
2460          #Running MFAToolkit          #Running MFAToolkit
2461          my $filename = $self->figmodel()->filename();          my $filename = $self->figmodel()->filename();
2462          my $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($filename,$self->id(),$media,["MFA"],{"Recursive MILP solution limit" => $solutionnum,"Generate pathways to objective" => 1,"MFASolver" => "CPLEX","objective" => $objectivestring,"exchange species" => $additionalexchange},"MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",undef,$self->selected_version());          my $command;
2463            if (defined($AllReversible) && $AllReversible == 1) {
2464                    $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($filename,$self->id(),$media,["ProductionMFA"],{"use simple variable and constraint names"=>1,"Make all reactions reversible in MFA"=>1, "Recursive MILP solution limit" => $solutionnum,"Generate pathways to objective" => 1,"MFASolver" => "SCIP","objective" => $objectivestring,"exchange species" => $additionalexchange},"MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",undef,$self->selected_version());
2465            } else {
2466                    $command = $self->figmodel()->GenerateMFAToolkitCommandLineCall($filename,$self->id(),$media,["ProductionMFA"],{"use simple variable and constraint names"=>1,"Make all reactions reversible in MFA"=>0, "Recursive MILP solution limit" => $solutionnum,"Generate pathways to objective" => 1,"MFASolver" => "SCIP","objective" => $objectivestring,"exchange species" => $additionalexchange},"MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",undef,$self->selected_version());
2467            }
2468            print $command."\n";
2469          system($command);          system($command);
2470    
2471          #Loading problem report          #Loading problem report
# Line 1972  Line 2473 
2473          #Clearing output          #Clearing output
2474          $self->figmodel()->clearing_output($filename,"MinimalPathways-".$media."-".$self->id()."-".$objective.".txt");          $self->figmodel()->clearing_output($filename,"MinimalPathways-".$media."-".$self->id()."-".$objective.".txt");
2475          if (!defined($results)) {          if (!defined($results)) {
2476                    print STDERR $objective." pathway results not found!\n";
2477                  return;                  return;
2478          }          }
2479    
# Line 1983  Line 2485 
2485                  @Array = /\d+:([^\|]+)\|/g;                  @Array = /\d+:([^\|]+)\|/g;
2486          }          }
2487    
2488          # Storing data in a figmodel table          #Writing output to file
2489          my $TableObject;          $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join("|",@Array)]);
2490          if (-e $self->directory()."MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt") {  }
2491                  $TableObject->load_table($self->directory()."MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",";","|",0,["OBJECTIVE"]);  
2492          } else {  sub combine_minimal_pathways {
2493                  $TableObject = FIGMODELTable->new(["OBJECTIVE","REACTIONS"],$self->directory()."MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",["OBJECTIVE"],";","|",undef);          my ($self) = @_;
2494          }  
2495          my $tablerow = $TableObject->get_row_by_key($objective,"OBJECTIVE",1);          my $tbl;
2496          push(@{$tablerow->{"REACTIONS"}},@Array);          if (-e $self->directory()."MinimalPathwayTable-".$self->id().$self->selected_version().".tbl") {
2497          $TableObject->save();                  $tbl = FIGMODELTable::load_table($self->directory()."MinimalPathwayTable-".$self->id().$self->selected_version().".tbl",";","|",0,["Objective","Media","Reversible"]);
2498            } else {
2499                    $tbl = FIGMODELTable->new(["Objective","Media","Reactions","Reversible","Shortest path","Number of essentials","Essentials","Length"],$self->directory()."MinimalPathwayTable-".$self->id().$self->selected_version().".tbl",["Objective","Media","Reversible"],";","|");
2500            }
2501            my @files = glob($self->directory()."MinimalPathways-*");
2502            for (my $i=0; $i < @files;$i++) {
2503                    if ($files[$i] =~ m/MinimalPathways\-(\S+)\-(cpd\d\d\d\d\d)\-(\w+)\-(\d)\-/ || $files[$i] =~ m/MinimalPathways\-(\S+)\-(ENERGY)\-(\w+)\-(\d)\-/) {
2504                            my $reactions = $self->figmodel()->database()->load_single_column_file($files[$i],"");
2505                            if (defined($reactions) && @{$reactions} > 0 && length($reactions->[0]) > 0) {
2506                                    my $newrow = {"Objective"=>[$2],"Media"=>[$1],"Reversible"=>[$4]};
2507                                    my $row = $tbl->get_table_by_key($newrow->{"Objective"}->[0],"Objective")->get_table_by_key($newrow->{"Media"}->[0],"Media")->get_row_by_key($newrow->{"Reversible"}->[0],"Reversible");
2508                                    if (!defined($row)) {
2509                                            $row = $tbl->add_row($newrow);
2510                                    }
2511                                    $row->{Reactions} = $self->figmodel()->database()->load_single_column_file($files[$i],"");
2512                                    delete($row->{"Shortest path"});
2513                                    delete($row->{"Number of essentials"});
2514                                    delete($row->{"Essentials"});
2515                                    delete($row->{"Length"});
2516                                    for (my $j=0; $j < @{$row->{Reactions}}; $j++) {
2517                                            my @array = split(/,/,$row->{Reactions}->[$j]);
2518                                            $row->{"Length"}->[$j] = @array;
2519                                            if (!defined($row->{"Shortest path"}->[0]) || $row->{"Length"}->[$j] < $row->{"Shortest path"}->[0]) {
2520                                                    $row->{"Shortest path"}->[0] = $row->{"Length"}->[$j];
2521                                            }
2522                                            $row->{"Number of essentials"}->[0] = 0;
2523                                            for (my $k=0; $k < @array;$k++) {
2524                                                    if ($array[$k] =~ m/(rxn\d\d\d\d\d)/) {
2525                                                            my $class = $self->get_reaction_class($1,1);
2526                                                            my $temp = $row->{Media}->[0].":Essential";
2527                                                            if ($class =~ m/$temp/) {
2528                                                                    $row->{"Number of essentials"}->[$j]++;
2529                                                                    if (!defined($row->{"Essentials"}->[$j]) && length($row->{"Essentials"}->[$j]) > 0) {
2530                                                                            $row->{"Essentials"}->[$j] = $array[$k];
2531                                                                    } else {
2532                                                                            $row->{"Essentials"}->[$j] .= ",".$array[$k];
2533                                                                    }
2534                                                            }
2535                                                    }
2536                                            }
2537                                    }
2538                            }
2539                    }
2540            }
2541            $tbl->save();
2542  }  }
2543    
2544  =head3 calculate_growth  =head3 calculate_growth
# Line 2036  Line 2582 
2582          7.) Dead: these reactions are disconnected from the network.          7.) Dead: these reactions are disconnected from the network.
2583  =cut  =cut
2584  sub classify_model_reactions {  sub classify_model_reactions {
2585          my ($self,$Media) = @_;          my ($self,$Media,$SaveChanges) = @_;
2586    
2587          #Getting unique file for printing model output          #Getting unique file for printing model output
2588          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
# Line 2123  Line 2669 
2669                                  $CpdRow->{MEDIA}->[$index] = $Media;                                  $CpdRow->{MEDIA}->[$index] = $Media;
2670                          }                          }
2671                  }                  }
2672                    if (!defined($SaveChanges) || $SaveChanges == 1) {
2673                  $cpdclasstable->save();                  $cpdclasstable->save();
2674          }          }
2675            }
2676          if (defined($ReactionTB)) {          if (defined($ReactionTB)) {
2677                  for (my $i=0; $i < $ReactionTB->size(); $i++) {                  for (my $i=0; $i < $ReactionTB->size(); $i++) {
2678                          my $Row = $ReactionTB->get_row($i);                          my $Row = $ReactionTB->get_row($i);
# Line 2179  Line 2727 
2727                                  $RxnRow->{MEDIA}->[$index] = $Media;                                  $RxnRow->{MEDIA}->[$index] = $Media;
2728                          }                          }
2729                  }                  }
2730                    if (!defined($SaveChanges) || $SaveChanges == 1) {
2731                  $rxnclasstable->save();                  $rxnclasstable->save();
2732          }          }
2733            }
2734          return ($rxnclasstable,$cpdclasstable);          return ($rxnclasstable,$cpdclasstable);
2735  }  }
2736    
# Line 2212  Line 2762 
2762    
2763          #Running simulations          #Running simulations
2764          system($self->config("mfalite executable")->[0]." ".$self->config("Reaction database directory")->[0]."masterfiles/MediaTable.txt ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/Jobfile.txt ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/Output.txt");          system($self->config("mfalite executable")->[0]." ".$self->config("Reaction database directory")->[0]."masterfiles/MediaTable.txt ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/Jobfile.txt ".$self->config("MFAToolkit output directory")->[0].$UniqueFilename."/Output.txt");
         print "simulation complete for ".$self->id().$self->selected_version()."\n";  
2765          #Parsing the results          #Parsing the results
2766          my $Results = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/Output.txt",";","\\|",0,undef);          my $Results = $self->figmodel()->database()->load_table($self->config("MFAToolkit output directory")->[0].$UniqueFilename."/Output.txt",";","\\|",0,undef);
2767          if (!defined($Results)) {          if (!defined($Results)) {
# Line 2619  Line 3168 
3168                                          if (length($GapFillingRunSpecs) > 0) {                                          if (length($GapFillingRunSpecs) > 0) {
3169                                                  $GapFillingRunSpecs .= ";";                                                  $GapFillingRunSpecs .= ";";
3170                                          }                                          }
3171                                          $GapFillingRunSpecs .= $HeadingDataArray[2].":".$HeadingDataArray[1].".txt:".$HeadingDataArray[3];                                          $GapFillingRunSpecs .= $HeadingDataArray[2].":".$HeadingDataArray[1].":".$HeadingDataArray[3];
3172                                  } else {                                  } else {
3173                                          $SolutionExistedCount++;                                          $SolutionExistedCount++;
3174                                  }                                  }
# Line 2644  Line 3193 
3193          my $SolutionsFound = 0;          my $SolutionsFound = 0;
3194          my $GapFillingArray;          my $GapFillingArray;
3195          push(@{$GapFillingArray},split(/;/,$GapFillingRunSpecs));          push(@{$GapFillingArray},split(/;/,$GapFillingRunSpecs));
3196          $self->datagapfill($GapFillingArray);          my $GapFillingResults = $self->datagapfill($GapFillingArray,"GFS");
3197            if (defined($GapFillingResults)) {
3198                    $SolutionsFound = 1;
3199            }
3200    
3201          if (defined($RescuedPreviousResults) && @{$RescuedPreviousResults} > 0) {          if (defined($RescuedPreviousResults) && @{$RescuedPreviousResults} > 0) {
3202                  #Printing previous solutions to GFS file                  #Printing previous solutions to GFS file
# Line 2667  Line 3219 
3219          return $self->success();          return $self->success();
3220  }  }
3221    
3222    =head3 SolutionReconciliation
3223    Definition:
3224            FIGMODELmodel->SolutionReconciliation();
3225    Description:
3226            This is a wrapper for running the solution reconciliation algorithm on any model in the database.
3227            The algorithm performs a reconciliation of any gap filling solutions to identify the combination of solutions that results in the optimal model.
3228            This function prints out one output file in the Model directory: ReconciliationOutput.txt: this is a summary of the results of the reconciliation analysis
3229    =cut
3230    
3231    sub SolutionReconciliation {
3232            my ($self,$GapFill,$Stage) = @_;
3233    
3234            #Setting the output filenames
3235            my $OutputFilename;
3236            my $OutputFilenameTwo;
3237            if ($GapFill == 1) {
3238                    $OutputFilename = $self->directory().$self->id().$self->selected_version()."-GFReconciliation.txt";
3239                    $OutputFilenameTwo = $self->directory().$self->id().$self->selected_version()."-GFSRS.txt";
3240            } else {
3241                    $OutputFilename = $self->directory().$self->id().$self->selected_version()."-GGReconciliation.txt";
3242                    $OutputFilenameTwo = $self->directory().$self->id().$self->selected_version()."-GGSRS.txt";
3243            }
3244    
3245            #In stage one, we run the reconciliation and create a test file to check combined solution performance
3246            if (!defined($Stage) || $Stage == 1) {
3247                    my $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3248                    my $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3249                    $Row->{"GF RECONCILATION TIMING"}->[0] = time()."-";
3250                    $GrowMatchTable->save();
3251                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3252    
3253                    #Getting a unique filename
3254                    my $UniqueFilename = $self->figmodel()->filename();
3255    
3256                    #Copying over the necessary files
3257                    if ($GapFill == 1) {
3258                            if (!-e $self->directory().$self->id().$self->selected_version()."-GFEM.txt") {
3259                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-GFEM.txt file not found. Could not reconcile!";
3260                                    return 0;
3261                            }
3262                            if (!-e $self->directory().$self->id().$self->selected_version()."-OPEM.txt") {
3263                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-OPEM.txt file not found. Could not reconcile!";
3264                                    return 0;
3265                            }
3266                            system("cp ".$self->directory().$self->id().$self->selected_version()."-GFEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-GFEM.txt");
3267                            system("cp ".$self->directory().$self->id().$self->selected_version()."-OPEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-OPEM.txt");
3268                            #Backing up and deleting the existing reconciliation file
3269                            if (-e $OutputFilename) {
3270                                    system("cp ".$OutputFilename." ".$self->directory().$self->id().$self->selected_version()."-OldGFReconciliation.txt");
3271                                    unlink($OutputFilename);
3272                            }
3273                    } else {
3274                            if (!-e $self->directory().$self->id().$self->selected_version()."-GGEM.txt") {
3275                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-GGEM.txt file not found. Could not reconcile!";
3276                                    return 0;
3277                            }
3278                            if (!-e $self->directory().$self->id().$self->selected_version()."-GGOPEM.txt") {
3279                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-GGOPEM.txt file not found. Could not reconcile!";
3280                                    return 0;
3281                            }
3282                            system("cp ".$self->directory().$self->id().$self->selected_version()."-GGEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-GGEM.txt");
3283                            system("cp ".$self->directory().$self->id().$self->selected_version()."-GGOPEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-OPEM.txt");
3284                            #Backing up and deleting the existing reconciliation file
3285                            if (-e $OutputFilename) {
3286                                    system("cp ".$OutputFilename." ".$self->directory().$self->id().$self->selected_version()."-OldGGReconciliation.txt");
3287                                    unlink($OutputFilename);
3288                            }
3289                    }
3290    
3291                    #Running the reconciliation
3292                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),"NONE",["SolutionReconciliation"],{"Solution data for model optimization" => $UniqueFilename},"Reconciliation".$UniqueFilename.".log",undef,$self->selected_version()));
3293                    $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3294                    $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3295                    $Row->{"GF RECONCILATION TIMING"}->[0] .= time();
3296                    $GrowMatchTable->save();
3297                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3298    
3299                    #Loading the problem report from the reconciliation run
3300                    my $ReconciliatonOutput = $self->figmodel()->LoadProblemReport($UniqueFilename);
3301                    print $UniqueFilename."\n";
3302                    #Clearing output files
3303                    $self->figmodel()->clearing_output($UniqueFilename,"Reconciliation".$UniqueFilename.".log");
3304                    $ReconciliatonOutput->save("/home/chenry/Test.txt");
3305    
3306                    #Checking the a problem report was found and was loaded
3307                    if (!defined($ReconciliatonOutput) || $ReconciliatonOutput->size() < 1 || !defined($ReconciliatonOutput->get_row(0)->{"Notes"}->[0])) {
3308                            print STDERR "FIGMODEL:SolutionReconciliation: MFAToolkit output from SolutionReconciliation of ".$self->id()." not found!\n\n";
3309                            return 0;
3310                    }
3311    
3312                    #Processing the solutions
3313                    my $SolutionCount = 0;
3314                    my $ReactionSetHash;
3315                    my $SingleReactionHash;
3316                    my $ReactionDataHash;
3317                    for (my $n=0; $n < $ReconciliatonOutput->size(); $n++) {
3318                            if (defined($ReconciliatonOutput->get_row($n)->{"Notes"}->[0]) && $ReconciliatonOutput->get_row($n)->{"Notes"}->[0] =~ m/^Recursive\sMILP\s([^;]+)/) {
3319                                    #Breaking up the solution into reaction sets
3320                                    my @ReactionSets = split(/\|/,$1);
3321                                    #Creating reaction lists for each set
3322                                    my $SolutionHash;
3323                                    for (my $i=0; $i < @ReactionSets; $i++) {
3324                                            if (length($ReactionSets[$i]) > 0) {
3325                                                    my @Alternatives = split(/:/,$ReactionSets[$i]);
3326                                                    for (my $j=1; $j < @Alternatives; $j++) {
3327                                                            if (length($Alternatives[$j]) > 0) {
3328                                                                    push(@{$SolutionHash->{$Alternatives[$j]}},$Alternatives[0]);
3329                                                            }
3330                                                    }
3331                                                    if (@Alternatives == 1) {
3332                                                            $SingleReactionHash->{$Alternatives[0]}->{$SolutionCount} = 1;
3333                                                            if (!defined($SingleReactionHash->{$Alternatives[0]}->{"COUNT"})) {
3334                                                                    $SingleReactionHash->{$Alternatives[0]}->{"COUNT"} = 0;
3335                                                            }
3336                                                            $SingleReactionHash->{$Alternatives[0]}->{"COUNT"}++;
3337                                                    }
3338                                            }
3339                                    }
3340                                    #Identifying reactions sets and storing the sets in the reactions set hash
3341                                    foreach my $Solution (keys(%{$SolutionHash})) {
3342                                            my $SetKey = join(",",sort(@{$SolutionHash->{$Solution}}));
3343                                            if (!defined($ReactionSetHash->{$SetKey}->{$SetKey}->{$SolutionCount})) {
3344                                                    $ReactionSetHash->{$SetKey}->{$SetKey}->{$SolutionCount} = 1;
3345                                                    if (!defined($ReactionSetHash->{$SetKey}->{$SetKey}->{"COUNT"})) {
3346                                                            $ReactionSetHash->{$SetKey}->{$SetKey}->{"COUNT"} = 0;
3347                                                    }
3348                                                    $ReactionSetHash->{$SetKey}->{$SetKey}->{"COUNT"}++;
3349                                            }
3350                                            $ReactionSetHash->{$SetKey}->{$Solution}->{$SolutionCount} = 1;
3351                                            if (!defined($ReactionSetHash->{$SetKey}->{$Solution}->{"COUNT"})) {
3352                                                    $ReactionSetHash->{$SetKey}->{$Solution}->{"COUNT"} = 0;
3353                                            }
3354                                            $ReactionSetHash->{$SetKey}->{$Solution}->{"COUNT"}++;
3355                                    }
3356                                    $SolutionCount++;
3357                            }
3358                    }
3359    
3360                    #Handling the scenario where no solutions were found
3361                    if ($SolutionCount == 0) {
3362                            print STDERR "FIGMODEL:SolutionReconciliation: Reconciliation unsuccessful. No solution found.\n\n";
3363                            return 0;
3364                    }
3365    
3366                    #Printing results without solution performance figures. Also printing solution test file
3367                    open (RECONCILIATION, ">$OutputFilename");
3368                    #Printing the file heading
3369                    print RECONCILIATION "DATABASE;DEFINITION;REVERSIBLITY;DELTAG;DIRECTION;NUMBER OF SOLUTIONS";
3370                    for (my $i=0; $i < $SolutionCount; $i++) {
3371                            print RECONCILIATION ";Solution ".$i;
3372                    }
3373                    print RECONCILIATION "\n";
3374                    #Printing the singlet reactions first
3375                    my $Solutions;
3376                    print RECONCILIATION "SINGLET REACTIONS\n";
3377                    my @SingletReactions = keys(%{$SingleReactionHash});
3378                    for (my $j=0; $j < $SolutionCount; $j++) {
3379                            $Solutions->[$j]->{"BASE"} = $j;
3380                    }
3381                    for (my $i=0; $i < @SingletReactions; $i++) {
3382                            my $ReactionData;
3383                            if (defined($ReactionDataHash->{$SingletReactions[$i]})) {
3384                                    $ReactionData = $ReactionDataHash->{$SingletReactions[$i]};
3385                            } else {
3386                                    my $Direction = substr($SingletReactions[$i],0,1);
3387                                    if ($Direction eq "+") {
3388                                            $Direction = "=>";
3389                                    } else {
3390                                            $Direction = "<=";
3391                                    }
3392                                    my $Reaction = substr($SingletReactions[$i],1);
3393                                    $ReactionData = FIGMODELObject->load($self->figmodel()->config("reaction directory")->[0].$Reaction,"\t");
3394                                    $ReactionData->{"DIRECTIONS"}->[0] = $Direction;
3395                                    $ReactionData->{"REACTIONS"}->[0] = $Reaction;
3396                                    if (!defined($ReactionData->{"DEFINITION"}->[0])) {
3397                                            $ReactionData->{"DEFINITION"}->[0] = "UNKNOWN";
3398                                    }
3399                                    if (!defined($ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0])) {
3400                                            $ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0] = "UNKNOWN";
3401                                    }
3402                                    if (!defined($ReactionData->{"DELTAG"}->[0])) {
3403                                            $ReactionData->{"DELTAG"}->[0] = "UNKNOWN";
3404                                    }
3405                                    $ReactionDataHash->{$SingletReactions[$i]} = $ReactionData;
3406                            }
3407                            print RECONCILIATION $ReactionData->{"REACTIONS"}->[0].";".$ReactionData->{"DEFINITION"}->[0].";".$ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0].";".$ReactionData->{"DELTAG"}->[0].";".$ReactionData->{"DIRECTIONS"}->[0].";".$SingleReactionHash->{$SingletReactions[$i]}->{"COUNT"};
3408                            for (my $j=0; $j < $SolutionCount; $j++) {
3409                                    print RECONCILIATION ";";
3410                                    if (defined($SingleReactionHash->{$SingletReactions[$i]}->{$j})) {
3411                                            $Solutions->[$j]->{$SingletReactions[$i]} = 1;
3412                                            $Solutions->[$j]->{"BASE"} = $j;
3413                                            print RECONCILIATION "|".$j."|";
3414                                    }
3415                            }
3416                            print RECONCILIATION "\n";
3417                    }
3418                    #Printing the reaction sets with alternatives
3419                    print RECONCILIATION "Reaction sets with alternatives\n";
3420                    my @ReactionSets = keys(%{$ReactionSetHash});
3421                    foreach my $ReactionSet (@ReactionSets) {
3422                            my $NewSolutions;
3423                            my $BaseReactions;
3424                            my $AltList = [$ReactionSet];
3425                            push(@{$AltList},keys(%{$ReactionSetHash->{$ReactionSet}}));
3426                            for (my $j=0; $j < @{$AltList}; $j++) {
3427                                    my $CurrentNewSolutions;
3428                                    my $Index;
3429                                    if ($j == 0) {
3430                                            print RECONCILIATION "NEW SET\n";
3431                                    } elsif ($AltList->[$j] ne $ReactionSet) {
3432                                            print RECONCILIATION "ALTERNATIVE SET\n";
3433                                            #For each base solution in which this set is represented, we copy the base solution to the new solution
3434                                            my $NewSolutionCount = 0;
3435                                            for (my $k=0; $k < $SolutionCount; $k++) {
3436                                                    if (defined($ReactionSetHash->{$ReactionSet}->{$AltList->[$j]}->{$k})) {
3437                                                            if (defined($Solutions)) {
3438                                                                    $Index->{$k} = @{$Solutions} + $NewSolutionCount;
3439                                                            } else {
3440                                                                    $Index->{$k} = $NewSolutionCount;
3441                                                            }
3442                                                            if (defined($NewSolutions) && @{$NewSolutions} > 0) {
3443                                                                    $Index->{$k} += @{$NewSolutions};
3444                                                            }
3445                                                            $CurrentNewSolutions->[$NewSolutionCount] = {};
3446                                                            foreach my $Reaction (keys(%{$Solutions->[$k]})) {
3447                                                                    $CurrentNewSolutions->[$NewSolutionCount]->{$Reaction} = $Solutions->[$k]->{$Reaction};
3448                                                            }
3449                                                            $NewSolutionCount++;
3450                                                    }
3451                                            }
3452                                    }
3453                                    if ($j == 0 || $AltList->[$j] ne $ReactionSet) {
3454                                            my @SingletReactions = split(/,/,$AltList->[$j]);
3455                                            for (my $i=0; $i < @SingletReactions; $i++) {
3456                                                    #Adding base reactions to base solutions and set reactions the new solutions
3457                                                    if ($j == 0) {
3458                                                            push(@{$BaseReactions},$SingletReactions[$i]);
3459                                                    } else {
3460                                                            for (my $k=0; $k < @{$CurrentNewSolutions}; $k++) {
3461                                                                    $CurrentNewSolutions->[$k]->{$SingletReactions[$i]} = 1;
3462                                                            }
3463                                                    }
3464                                                    #Getting reaction data and printing reaction in output file
3465                                                    my $ReactionData;
3466                                                    if (defined($ReactionDataHash->{$SingletReactions[$i]})) {
3467                                                            $ReactionData = $ReactionDataHash->{$SingletReactions[$i]};
3468                                                    } else {
3469                                                            my $Direction = substr($SingletReactions[$i],0,1);
3470                                                            if ($Direction eq "+") {
3471                                                                    $Direction = "=>";
3472                                                            } else {
3473                                                                    $Direction = "<=";
3474                                                            }
3475                                                            my $Reaction = substr($SingletReactions[$i],1);
3476                                                            $ReactionData = FIGMODELObject->load($self->figmodel()->config("reaction directory")->[0].$Reaction,"\t");
3477                                                            $ReactionData->{"DIRECTIONS"}->[0] = $Direction;
3478                                                            $ReactionData->{"REACTIONS"}->[0] = $Reaction;
3479                                                            if (!defined($ReactionData->{"DEFINITION"}->[0])) {
3480                                                                    $ReactionData->{"DEFINITION"}->[0] = "UNKNOWN";
3481                                                            }
3482                                                            if (!defined($ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0])) {
3483                                                                    $ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0] = "UNKNOWN";
3484                                                            }
3485                                                            if (!defined($ReactionData->{"DELTAG"}->[0])) {
3486                                                                    $ReactionData->{"DELTAG"}->[0] = "UNKNOWN";
3487                                                            }
3488                                                            $ReactionDataHash->{$SingletReactions[$i]} = $ReactionData;
3489                                                    }
3490                                                    print RECONCILIATION $ReactionData->{"REACTIONS"}->[0].";".$ReactionData->{"DEFINITION"}->[0].";".$ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0].";".$ReactionData->{"DELTAG"}->[0].";".$ReactionData->{"DIRECTIONS"}->[0].";".$ReactionSetHash->{$ReactionSet}->{$AltList->[$j]}->{"COUNT"};
3491                                                    for (my $k=0; $k < $SolutionCount; $k++) {
3492                                                            print RECONCILIATION ";";
3493                                                            if (defined($ReactionSetHash->{$ReactionSet}->{$AltList->[$j]}->{$k})) {
3494                                                                    if ($j == 0) {
3495                                                                            print RECONCILIATION "|".$k."|";
3496                                                                    } else {
3497                                                                            print RECONCILIATION "|".$Index->{$k}."|";
3498                                                                    }
3499                                                            }
3500                                                    }
3501                                                    print RECONCILIATION "\n";
3502                                            }
3503                                            #Adding the current new solutions to the new solutions array
3504                                            if (defined($CurrentNewSolutions) && @{$CurrentNewSolutions} > 0) {
3505                                                    push(@{$NewSolutions},@{$CurrentNewSolutions});
3506                                            }
3507                                    }
3508                            }
3509                            #Adding the base reactions to all existing solutions
3510                            for (my $j=0; $j < @{$Solutions}; $j++) {
3511                                    if (defined($ReactionSetHash->{$ReactionSet}->{$ReactionSet}->{$Solutions->[$j]->{"BASE"}})) {
3512                                            foreach my $SingleReaction (@{$BaseReactions}) {
3513                                                    $Solutions->[$j]->{$SingleReaction} = 1;
3514                                            }
3515                                    }
3516                            }
3517                            #Adding the new solutions to the set of existing solutions
3518                            push(@{$Solutions},@{$NewSolutions});
3519                    }
3520                    close(RECONCILIATION);
3521                    #Now printing a file that defines all of the solutions in a format the testsolutions function understands
3522                    open (RECONCILIATION, ">$OutputFilenameTwo");
3523                    print RECONCILIATION "Experiment;Solution index;Solution cost;Solution reactions\n";
3524                    for (my $i=0; $i < @{$Solutions}; $i++) {
3525                            delete($Solutions->[$i]->{"BASE"});
3526                            print RECONCILIATION "SR".$i.";".$i.";10;".join(",",keys(%{$Solutions->[$i]}))."\n";
3527                    }
3528                    close(RECONCILIATION);
3529    
3530                    $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3531                    $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3532                    $Row->{"GF RECON TESTING TIMING"}->[0] = time()."-";
3533                    $Row->{"GF RECON SOLUTIONS"}->[0] = @{$Solutions};
3534                    $GrowMatchTable->save();
3535                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3536    
3537                    #Scheduling the solution testing
3538                    if ($GapFill == 1) {
3539                            system($self->figmodel()->config("scheduler executable")->[0]." \"add:testsolutions?".$self->id().$self->selected_version()."?-1?GFSR:BACK:fast:QSUB\"");
3540                    } else {
3541                            system($self->figmodel()->config("scheduler executable")->[0]." \"add:testsolutions?".$self->id().$self->selected_version()."?-1?GGSR:BACK:fast:QSUB\"");
3542                    }
3543            } else {
3544                    #Reading in the solution testing results
3545                    my $Data;
3546                    if ($GapFill == 1) {
3547                            $Data = $self->figmodel()->database()->load_single_column_file($self->directory().$self->id().$self->selected_version()."-GFSREM.txt","");
3548                    } else {
3549                            $Data = $self->figmodel()->database()->load_single_column_file($self->directory().$self->id().$self->selected_version()."-GGSREM.txt","");
3550                    }
3551    
3552                    #Reading in the preliminate reconciliation report
3553                    my $OutputData = $self->figmodel()->database()->load_single_column_file($OutputFilename,"");
3554                    #Replacing the file tags with actual performance data
3555                    my $Count = 0;
3556                    for (my $i=0; $i < @{$Data}; $i++) {
3557                            if ($Data->[$i] =~ m/^SR(\d+);.+;(\d+\/\d+);/) {
3558                                    my $Index = $1;
3559                                    my $Performance = $Index."/".$2;
3560                                    for (my $j=0; $j < @{$OutputData}; $j++) {
3561                                            $OutputData->[$j] =~ s/\|$Index\|/$Performance/g;
3562                                    }
3563                            }
3564                    }
3565                    $self->figmodel()->database()->print_array_to_file($OutputFilename,$OutputData);
3566    
3567                    my $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3568                    my $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3569                    $Row->{"GF RECON TESTING TIMING"}->[0] .= time();
3570                    $GrowMatchTable->save();
3571                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3572            }
3573    
3574            return 1;
3575    }
3576    
3577  =head3 BuildSpecificBiomassReaction  =head3 BuildSpecificBiomassReaction
3578  Definition:  Definition:
3579          FIGMODELmodel->BuildSpecificBiomassReaction();          FIGMODELmodel->BuildSpecificBiomassReaction();
# Line 2679  Line 3586 
3586          my $OrganismID = $self->genome();          my $OrganismID = $self->genome();
3587          #Checking for a biomass override          #Checking for a biomass override
3588          if (defined($self->config("biomass reaction override")->{$OrganismID})) {          if (defined($self->config("biomass reaction override")->{$OrganismID})) {
3589                  $biomassrxn = $self->config("biomass reaction override")->{$OrganismID};                  my $biomassID = $self->config("biomass reaction override")->{$OrganismID};
3590                  print "Overriding biomass template and selecting ".$biomassrxn." for ".$OrganismID.".\n";                  my $tbl = $self->database()->get_table("BIOMASS",1);
3591                    $biomassrxn = $tbl->get_row_by_key($biomassID,"DATABASE");
3592                    print "Overriding biomass template and selecting ".$biomassID." for ".$OrganismID.".\n";
3593          } else {#Creating biomass reaction from the template          } else {#Creating biomass reaction from the template
3594                  #Getting the genome stats                  #Getting the genome stats
3595                  my $genomestats = $self->figmodel()->get_genome_stats($self->genome());                  my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
# Line 2971  Line 3880 
3880    
3881                  #Adding the biomass equation to the biomass table                  #Adding the biomass equation to the biomass table
3882                  my $NewRow = $self->figmodel()->add_biomass_reaction($Equation,$self->id(),"Template:".$self->genome());                  my $NewRow = $self->figmodel()->add_biomass_reaction($Equation,$self->id(),"Template:".$self->genome());
3883                  $biomassrxn = $NewRow->{DATABASE}->[0];                  $biomassrxn = $NewRow;
                 print $biomassrxn."\n";  
3884          }          }
3885          print $biomassrxn."\n";          return $biomassrxn;
         my $BiomassRow = $self->figmodel()->add_model_to_biomass_reaction($biomassrxn,$self->id());  
         return $BiomassRow;  
3886  }  }
3887    
3888  =head3 PrintSBMLFile  =head3 PrintSBMLFile
# Line 3287  Line 4193 
4193          $self->figmodel()->clearing_output($UniqueFilename,"FBA-".$self->id().$self->selected_version().".lp");          $self->figmodel()->clearing_output($UniqueFilename,"FBA-".$self->id().$self->selected_version().".lp");
4194  }  }
4195    
4196    =head3 patch_model
4197    Definition:
4198            FIGMODELTable:patch results = FIGMODELmodel->patch_model(FIGMODELTable:patch table);
4199    Description:
4200    =cut
4201    sub patch_model {
4202            my ($self,$tbl) = @_;
4203    
4204            #Instantiating table
4205            my $results = FIGMODELTable->new(["Reactions","New genes","Old genes","Genes","Roles","Status"],$self->directory()."PatchResults-".$self->id().$self->selected_version().".tbl",["Reaction"],"\t",";",undef);
4206            #Getting genome annotations
4207            my $features = $self->figmodel()->database()->get_genome_feature_table($self->genome());
4208            #Gettubg reaction table
4209            my $reactions = $self->reaction_table();
4210            #Checking for patched roles
4211            for (my $i=0; $i < $tbl->size(); $i++) {
4212                    my $row = $tbl->get_row($i);
4213                    my @genes = $features->get_rows_by_key($row->{ROLE}->[0],"ROLES");
4214                    if (@genes > 0) {
4215                            for (my $j=0; $j < @{$row->{REACTIONS}};$j++) {
4216                                    my $resultrxn = $results->get_row_by_key($row->{REACTIONS}->[$j],"Reactions");
4217                                    if (!defined($resultrxn)) {
4218                                            $resultrxn = $results->add_row({"Reactions"=>[$row->{REACTIONS}->[$j]],"Roles"=>[$row->{ROLE}->[0]]});
4219                                    }
4220                                    my $rxnrow = $reactions->get_row_by_key($row->{REACTIONS}->[$j],"LOAD");
4221                                    if (defined($rxnrow) && !defined($resultrxn->{"Old genes"})) {
4222                                            $resultrxn->{"Old genes"} = $rxnrow->{"ASSOCIATED PEG"};
4223                                            if ($resultrxn->{"Old genes"}->[0] !~ m/GAP|BOF|UNIVERSAL|SPONTANEOUS/) {
4224                                                    push(@{$resultrxn->{"Genes"}},@{$resultrxn->{"Old genes"}});
4225                                            }
4226                                    }
4227                                    delete $resultrxn->{"Current gene set"};
4228                                    if (defined($resultrxn->{"Genes"})) {
4229                                            push(@{$resultrxn->{"Current gene set"}},@{$resultrxn->{"Genes"}});
4230                                    }
4231                                    for (my $k=0; $k < @genes; $k++) {
4232                                            if ($genes[$k]->{ID}->[0] =~ m/(peg\.\d+)/) {
4233                                                    my $gene = $1;
4234                                                    my $addgene = 1;
4235                                                    if (defined($resultrxn->{"Old genes"})) {
4236                                                            for (my $m=0; $m < @{$resultrxn->{"Old genes"}}; $m++) {
4237                                                                    if ($resultrxn->{"Old genes"}->[$m] =~ m/$gene/) {
4238                                                                            $addgene = 0;
4239                                                                    }
4240                                                            }
4241                                                    }
4242                                                    if ($addgene == 1) {
4243                                                            push(@{$resultrxn->{"New genes"}},$gene);
4244                                                            if ($row->{COMPLEX}->[0] ne "0" && defined($resultrxn->{"Current gene set"})) {
4245                                                                    my $added = 0;
4246                                                                    for (my $m=0; $m < @{$resultrxn->{"Current gene set"}}; $m++) {
4247                                                                            if ($row->{COMPLEX}->[0] eq "1") {
4248                                                                                    $resultrxn->{"Current gene set"}->[$m] = $resultrxn->{"Current gene set"}->[$m]."+".$gene;
4249                                                                                    $added = 1;
4250                                                                            } else {
4251                                                                                    my @geneset = split(/\+/,$resultrxn->{"Current gene set"}->[$m]);
4252                                                                                    for (my $n=0; $n < @geneset;$n++) {
4253                                                                                            if ($self->figmodel()->colocalized_genes($geneset[$n],$gene,$self->genome()) == 1) {
4254                                                                                                    $resultrxn->{"Current gene set"}->[$m] = $resultrxn->{"Current gene set"}->[$m]."+".$gene;
4255                                                                                                    $added = 1;
4256                                                                                                    last;
4257                                                                                            }
4258                                                                                    }
4259                                                                            }
4260                                                                    }
4261                                                                    if ($added == 0) {
4262                                                                            push(@{$resultrxn->{"Current gene set"}},$gene);
4263                                                                    }
4264                                                            } else {
4265                                                                    push(@{$resultrxn->{"Current gene set"}},$gene);
4266                                                            }
4267                                                    }
4268                                            }
4269                                    }
4270                                    delete $resultrxn->{"Genes"};
4271                                    push(@{$resultrxn->{"Genes"}},@{$resultrxn->{"Current gene set"}});
4272                            }
4273                    }
4274            }
4275    
4276            #Ensuring that the old model is preserved
4277            $self->ArchiveModel();
4278            #Modifing the reaction list
4279            for (my $i=0; $i < $results->size();$i++) {
4280                    my $row = $results->get_row($i);
4281                    my $rxnrow = $reactions->get_row_by_key($row->{"Reactions"}->[0],"LOAD");
4282                    if (defined($rxnrow)) {
4283                            $rxnrow->{"ASSOCIATED PEG"} = $row->{"Genes"};
4284                    } else {
4285                            $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"]});
4286                    }
4287            }
4288            $reactions->save();
4289            $results->save();
4290            $self->update_model_stats();
4291            $self->PrintModelLPFile();
4292            $self->run_default_model_predictions();
4293            #Returning results
4294            return $results;
4295    }
4296    
4297    =head3 translate_genes
4298    Definition:
4299            FIGMODELmodel->translate_genes();
4300    Description:
4301    =cut
4302    sub translate_genes {
4303            my ($self) = @_;
4304    
4305            #Loading gene translations
4306            if (!defined($self->{_gene_aliases})) {
4307                    #Loading gene aliases from feature table
4308                    my $tbl = $self->figmodel()->GetGenomeFeatureTable($self->genome());
4309                    if (defined($tbl)) {
4310                            for (my $i=0; $i < $tbl->size(); $i++) {
4311                                    my $row = $tbl->get_row($i);
4312                                    if ($row->{ID}->[0] =~ m/(peg\.\d+)/) {
4313                                            my $geneID = $1;
4314                                            for (my $j=0; $j < @{$row->{ALIASES}}; $j++) {
4315                                                    $self->{_gene_aliases}->{$row->{ALIASES}->[$j]} = $geneID;
4316                                            }
4317                                    }
4318                            }
4319                    }
4320                    #Loading additional gene aliases from the database
4321                    if (-e $self->figmodel()->config("Translation directory")->[0]."AdditionalAliases/".$self->genome().".txt") {
4322                            my $AdditionalAliases = $self->figmodel()->database()->load_multiple_column_file($self->figmodel()->config("Translation directory")->[0]."AdditionalAliases/".$self->genome().".txt","\t");
4323                            for (my $i=0; $i < @{$AdditionalAliases}; $i++) {
4324                                    $self->{_gene_aliases}->{$AdditionalAliases->[$i]->[1]} = $AdditionalAliases->[$i]->[0];
4325                            }
4326                    }
4327            }
4328    
4329            #Cycling through reactions and translating genes
4330            for (my $i=0; $i < $self->reaction_table()->size(); $i++) {
4331                    my $row = $self->reaction_table()->get_row($i);
4332                    if (defined($row->{"ASSOCIATED PEG"})) {
4333                            for (my $j=0; $j < @{$row->{"ASSOCIATED PEG"}}; $j++) {
4334                                    my $Original = $row->{"ASSOCIATED PEG"}->[$j];
4335                                    $Original =~ s/\sand\s/:/g;
4336                                    $Original =~ s/\sor\s/;/g;
4337                                    my @GeneNames = split(/[,\+\s\(\):;]/,$Original);
4338                                    foreach my $Gene (@GeneNames) {
4339                                            if (length($Gene) > 0 && defined($self->{_gene_aliases}->{$Gene})) {
4340                                                    my $Replace = $self->{_gene_aliases}->{$Gene};
4341                                                    $Original =~ s/([^\w])$Gene([^\w])/$1$Replace$2/g;
4342                                                    $Original =~ s/^$Gene([^\w])/$Replace$1/g;
4343                                                    $Original =~ s/([^\w])$Gene$/$1$Replace/g;
4344                                                    $Original =~ s/^$Gene$/$Replace/g;
4345                                            }
4346                                    }
4347                                    $Original =~ s/:/ and /g;
4348                                    $Original =~ s/;/ or /g;
4349                                    $row->{"ASSOCIATED PEG"}->[$j] = $Original;
4350                            }
4351                    }
4352            }
4353    
4354            #Archiving model and saving reaction table
4355            $self->ArchiveModel();
4356            $self->reaction_table()->save();
4357    }
4358    
4359    =head3 feature_web_data
4360    Definition:
4361            string:web output for feature/model connection = FIGMODELmodel->feature_web_data(FIGMODELfeature:feature);
4362    Description:
4363    =cut
4364    sub feature_web_data {
4365            my ($self,$feature) = @_;
4366    
4367            #First checking if the feature is in the model
4368            my $data = $self->get_feature_data($feature->{ID}->[0]);
4369            if (!defined($data)) {
4370                    return "Not in model";
4371            }
4372    
4373            my $output;
4374            #Printing predictions
4375            if (defined($data->{$self->id()."PREDICTIONS"})) {
4376                    #Parsing essentiality data
4377                    my $essentialityData;
4378                    if (defined($feature->{ESSENTIALITY})) {
4379                            for (my $i=0; $i < @{$feature->{ESSENTIALITY}};$i++) {
4380                                    my @temp = split(/:/,$feature->{ESSENTIALITY}->[$i]);
4381                                    $essentialityData->{$temp[0]} = $temp[1];
4382                            }
4383                    }
4384                    my $predictionHash;
4385                    for (my $i=0; $i < @{$data->{$self->id()."PREDICTIONS"}};$i++) {
4386                            my @temp = split(/:/,$data->{$self->id()."PREDICTIONS"}->[$i]);
4387                            if (defined($essentialityData->{$temp[0]})) {
4388                                    if ($temp[1] eq "essential" && $essentialityData->{$temp[0]} eq "essential") {
4389                                            push(@{$predictionHash->{"Correct negative"}},$temp[0]);
4390                                    } elsif ($temp[1] eq "nonessential" && $essentialityData->{$temp[0]} eq "essential") {
4391                                            push(@{$predictionHash->{"False positive"}},$temp[0]);
4392                                    } elsif ($temp[1] eq "essential" && $essentialityData->{$temp[0]} eq "nonessential") {
4393                                            push(@{$predictionHash->{"False negative"}},$temp[0]);
4394                                    } elsif ($temp[1] eq "nonessential" && $essentialityData->{$temp[0]} eq "nonessential") {
4395                                            push(@{$predictionHash->{"Correct positive"}},$temp[0]);
4396                                    }
4397                            } else {
4398                                    push(@{$predictionHash->{$temp[1]}},$temp[0]);
4399                            }
4400                    }
4401                    foreach my $key (keys(%{$predictionHash})) {
4402                            my $string = $key;
4403                            $string = ucfirst($string);
4404                            push(@{$output},'<span title="'.join(", ",@{$predictionHash->{$key}}).'">'.$string.'</span>');
4405                    }
4406            }
4407    
4408            #Printing reactions
4409            if (defined($data->{$self->id()."REACTIONS"})) {
4410                    for (my $i=0; $i < @{$data->{$self->id()."REACTIONS"}};$i++) {
4411                            my $rxnData = $self->get_reaction_data($data->{$self->id()."REACTIONS"}->[$i]);
4412                            my $reactionString = $self->figmodel()->web()->create_reaction_link($data->{$self->id()."REACTIONS"}->[$i],join(" or ",@{$rxnData->{"ASSOCIATED PEG"}}),$self->id());
4413                            if (defined($rxnData->{PREDICTIONS})) {
4414                                    my $predictionHash;
4415                                    for (my $i=0; $i < @{$rxnData->{PREDICTIONS}};$i++) {
4416                                            my @temp = split(/:/,$rxnData->{PREDICTIONS}->[$i]);
4417                                            push(@{$predictionHash->{$temp[1]}},$temp[0]);
4418                                    }
4419                                    $reactionString .= "(";
4420                                    foreach my $key (keys(%{$predictionHash})) {
4421                                            if ($key eq "Essential =>") {
4422                                                    $reactionString .= '<span title="Essential in '.join(",",@{$predictionHash->{$key}}).'">E=></span>,';
4423                                            } elsif ($key eq "Essential <=") {
4424                                                    $reactionString .= '<span title="Essential in '.join(",",@{$predictionHash->{$key}}).'">E<=</span>,';
4425                                            } elsif ($key eq "Active =>") {
4426                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A=></span>,';
4427                                            } elsif ($key eq "Active <=") {
4428                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A<=</span>,';
4429                                            } elsif ($key eq "Active <=>") {
4430                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A</span>,';
4431                                            } elsif ($key eq "Inactive") {
4432                                                    $reactionString .= '<span title="Inactive in '.join(",",@{$predictionHash->{$key}}).'">I</span>,';
4433                                            } elsif ($key eq "Dead") {
4434                                                    $reactionString .= '<span title="Dead">D</span>,';
4435                                            }
4436                                    }
4437                                    $reactionString =~ s/,$/)/;
4438                            }
4439                            push(@{$output},$reactionString);
4440                    }
4441            }
4442    
4443            #Returning output
4444            return join("<br>",@{$output});
4445    }
4446    
4447    =head3 remove_obsolete_reactions
4448    Definition:
4449            void FIGMODELmodel->remove_obsolete_reactions();
4450    Description:
4451    =cut
4452    sub remove_obsolete_reactions {
4453            my ($self) = @_;
4454    
4455            (my $dummy,my $translation) = $self->figmodel()->put_two_column_array_in_hash($self->figmodel()->database()->load_multiple_column_file($self->figmodel()->config("Translation directory")->[0]."ObsoleteRxnIDs.txt","\t"));
4456            my $rxnTbl = $self->reaction_table();
4457            if (defined($rxnTbl)) {
4458                    for (my $i=0; $i < $rxnTbl->size(); $i++) {
4459                            my $row = $rxnTbl->get_row($i);
4460                            if (defined($translation->{$row->{LOAD}->[0]}) || defined($translation->{$row->{LOAD}->[0]."r"})) {
4461                                    my $direction = $row->{DIRECTION}->[0];
4462                                    my $newRxn;
4463                                    if (defined($translation->{$row->{LOAD}->[0]."r"})) {
4464                                            $newRxn = $translation->{$row->{LOAD}->[0]."r"};
4465                                            if ($direction eq "<=") {
4466                                                    $direction = "=>";
4467                                            } elsif ($direction eq "=>") {
4468                                                    $direction = "<=";
4469                                            }
4470                                    } else {
4471                                            $newRxn = $translation->{$row->{LOAD}->[0]};
4472                                    }
4473                                    #Checking if the new reaction is already in the model
4474                                    my $newRow = $rxnTbl->get_row_by_key($newRxn,"LOAD");
4475                                    if (defined($newRow)) {
4476                                            #Handling direction
4477                                            if ($newRow->{DIRECTION}->[0] ne $direction) {
4478                                                    $newRow->{DIRECTION}->[0] = "<=>";
4479                                            }
4480                                            push(@{$row->{"ASSOCIATED PEG"}},@{$rxnTbl->get_row($i)->{"ASSOCIATED PEG"}});
4481                                    } else {
4482                                            $rxnTbl->get_row($i)->{LOAD}->[0] = $newRxn;
4483                                            $rxnTbl->get_row($i)->{DIRECTION}->[0] = $direction;
4484                                    }
4485                            }
4486                    }
4487                    $rxnTbl->save();
4488            }
4489    }
4490    
4491  1;  1;

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.13

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3