[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.11, Thu Apr 15 21:51:15 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                                    $GeneSet =~ s/\+/|/g;
530                                    $GeneSet =~ s/\sAND\s/|/gi;
531                                    $GeneSet =~ s/\sOR\s/|/gi;
532                                    $GeneSet =~ s/[\(\)\s]//g;
533                                    my @GeneList = split(/\|/,$GeneSet);
534                                    foreach my $Gene (@GeneList) {
535                                    my $FeatureRow = $self->{_feature_data}->get_row_by_key("fig|".$self->genome().".".$Gene,"ID");
536                                                    if (!defined($FeatureRow)) {
537                                                            $FeatureRow = $FeatureTable->get_row_by_key("fig|".$self->genome().".".$Gene,"ID");
538                                                            if (defined($FeatureRow)) {
539                                                                    $self->{_feature_data}->add_row($FeatureRow);
540                                                            }
541                                                    }
542                                                    if (defined($FeatureRow)) {
543                                                            $self->{_feature_data}->add_data($FeatureRow,$self->id()."REACTIONS",$Row->{"LOAD"}->[0],1);
544                                                    }
545                                    }
546                            }
547                    }
548                }
549                #Loading predictions
550                my @files = glob($self->directory()."EssentialGenes-".$self->id()."-*");
551                foreach my $file (@files) {
552                    if ($file =~ m/\-([^\-]+)\.tbl/) {
553                            my $media = $1;
554                            my $list = $self->figmodel()->database()->load_single_column_file($file,"");
555                            my $hash;
556                            foreach my $gene (@{$list}) {
557                                    $hash->{$gene} = 1;
558                            }
559                            for (my $i=0; $i < $self->{_feature_data}->size(); $i++) {
560                                    my $Row = $self->{_feature_data}->get_row($i);
561                                    if ($Row->{ID}->[0] =~ m/(peg\.\d+)/) {
562                                            my $gene = $1;
563                                            if (defined($hash->{$gene})) {
564                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":essential");
565                                            } else {
566                                                    push(@{$Row->{$self->id()."PREDICTIONS"}},$media.":nonessential");
567                                            }
568                                    }
569                            }
570                    }
571                }
572            }
573            return $self->{_feature_data};
574    }
575    
576  =head3 reaction_class_table  =head3 reaction_class_table
577  Definition:  Definition:
578          FIGMODELTable = FIGMODELmodel->reaction_class_table();          FIGMODELTable = FIGMODELmodel->reaction_class_table();
# Line 438  Line 613 
613          return $self->{_compound_class_table};          return $self->{_compound_class_table};
614  }  }
615    
616    =head3 get_essential_genes
617    Definition:
618            [string::peg ID] = FIGMODELmodel->get_essential_genes(string::media condition);
619    Description:
620            Returns an reference to an array of the predicted essential genes during growth in the input media condition
621    =cut
622    sub get_essential_genes {
623            my ($self,$media) = @_;
624    
625            if (!defined($media)) {
626                    $media = "Complete";
627            }
628            if (!defined($self->{_essential_genes}->{$media})) {
629                    $self->{_essential_genes}->{$media} = undef;
630                    if (-e $self->directory()."EssentialGenes-".$self->id().$self->selected_version()."-".$media.".tbl") {
631                            $self->{_essential_genes}->{$media} = $self->figmodel()->database()->load_single_column_file($self->directory()."EssentialGenes-".$self->id().$self->selected_version()."-".$media.".tbl","");
632                    }
633            }
634    
635            return $self->{_essential_genes}->{$media};
636    }
637    
638  =head3 compound_table  =head3 compound_table
639  Definition:  Definition:
640          FIGMODELTable = FIGMODELmodel->compound_table();          FIGMODELTable = FIGMODELmodel->compound_table();
# Line 456  Line 653 
653    
654  =head3 get_compound_data  =head3 get_compound_data
655  Definition:  Definition:
656          string = FIGMODELmodel->get_compound_data(string::compound ID);          {string:key=>[string]:values} = FIGMODELmodel->get_compound_data(string::compound ID);
657  Description:  Description:
658          Returns model compound data          Returns model compound data
659  =cut  =cut
# Line 467  Line 664 
664                  return undef;                  return undef;
665          }          }
666          if ($compound =~ m/^\d+$/) {          if ($compound =~ m/^\d+$/) {
667                  $self->compound_table()->get_row($compound);                  return $self->compound_table()->get_row($compound);
668          }          }
669          return $self->compound_table()->get_row_by_key($compound,"DATABASE");          return $self->compound_table()->get_row_by_key($compound,"DATABASE");
670  }  }
671    
672    =head3 get_feature_data
673    Definition:
674            {string:key=>[string]:values} = FIGMODELmodel->get_feature_data(string::feature ID);
675    Description:
676            Returns model feature data
677    =cut
678    sub get_feature_data {
679            my ($self,$feature) = @_;
680            if (!defined($self->feature_table())) {
681                    return undef;
682            }
683            if ($feature =~ m/^\d+$/) {
684                    return $self->feature_table()->get_row($feature);
685            }
686            if ($feature =~ m/(peg\.\d+)/) {
687                    $feature = $1;
688            }
689            return $self->feature_table()->get_row_by_key("fig|".$self->genome().".".$feature,"ID");
690    }
691    
692  =head3 genome  =head3 genome
693  Definition:  Definition:
694          string = FIGMODELmodel->genome();          string = FIGMODELmodel->genome();
# Line 681  Line 898 
898                                  $self->{_modification_time} = $stats->{"Gap fill date"}->[0];                                  $self->{_modification_time} = $stats->{"Gap fill date"}->[0];
899                          }                          }
900                  } else {                  } else {
901                          $self->{_modification_time} = 0;                          $self->{_modification_time} = $self->{_data}->{date}->[0];
902                  }                  }
903          }          }
904          return $self->{_modification_time};          return $self->{_modification_time};
# Line 892  Line 1109 
1109          #Checking that the table is defined and the output file exists          #Checking that the table is defined and the output file exists
1110          if (defined($result) && defined($result->get_row(0)->{"ESSENTIALGENES"})) {          if (defined($result) && defined($result->get_row(0)->{"ESSENTIALGENES"})) {
1111                  $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"}})]);
1112            } else {
1113                    $self->figmodel()->error_message("FIGMODELmodel:run_default_model_predictions:could not identify essential reactions for model ".$self->id().$self->selected_version().".");
1114                    return $self->figmodel()->fail();
1115          }          }
1116    
1117          #Classifying reactions and compounds          #Classifying reactions and compounds
1118          my $tbl = $self->classify_model_reactions($Media);          my $tbl = $self->classify_model_reactions($Media);
1119            if (!defined($tbl)) {
1120                    $self->figmodel()->error_message("FIGMODELmodel:run_default_model_predictions:could not classify reactions for model ".$self->id().$self->selected_version().".");
1121                    return $self->figmodel()->fail();
1122            }
1123          $tbl->save();          $tbl->save();
1124    
1125          return $self->figmodel()->success();          return $self->figmodel()->success();
# Line 1049  Line 1273 
1273                                  $CurrentStats->{"Gap filling reactions"}->[0]++;                                  $CurrentStats->{"Gap filling reactions"}->[0]++;
1274                          } else {                          } else {
1275                                  foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {                                  foreach my $GeneSet (@{$Row->{"ASSOCIATED PEG"}}) {
1276                                          my @GeneList = split(/\+/,$GeneSet);                                          $_ = $GeneSet;
1277                                            my @GeneList = /(peg\.\d+)/g;
1278                                          foreach my $Gene (@GeneList) {                                          foreach my $Gene (@GeneList) {
1279                                                  if ($Gene =~ m/(peg\.\d+)/) {                                                  if ($Gene =~ m/(peg\.\d+)/) {
1280                                                          $GeneHash{$1} = 1;                                                          $GeneHash{$1} = 1;
# Line 1119  Line 1344 
1344                          }                          }
1345                  }                  }
1346                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  $MediaTable->save($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1347                  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));
1348                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");                  unlink($self->config("Media directory")->[0].$UniqueFilename."TestMedia.txt");
1349          } else {          } else {
1350                  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));
1351          }          }
1352    
1353          #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 1365 
1365          for (my $i=($SolutionData->size()-1); $i >=0; $i--) {          for (my $i=($SolutionData->size()-1); $i >=0; $i--) {
1366                  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/) {
1367                          my $AllSolutions = substr($SolutionData->get_row($i)->{"Notes"}->[0],15);                          my $AllSolutions = substr($SolutionData->get_row($i)->{"Notes"}->[0],15);
                         print "Solution:".$AllSolutions."\n";  
1368                          my @TempThree = split(/\|/,$AllSolutions);                          my @TempThree = split(/\|/,$AllSolutions);
1369                          if (@TempThree > 0 && $TempThree[0] =~ m/.+:(.+)/) {                          if (@TempThree > 0 && $TempThree[0] =~ m/.+:(.+)/) {
1370                                  my @TempFour = split(/,/,$1);                                  my @TempFour = split(/,/,$1);
# Line 1163  Line 1387 
1387                                                  push(@{$ReactionList},$ID);                                                  push(@{$ReactionList},$ID);
1388                                          }                                          }
1389                                  }                                  }
                                 print "Solution:".$TempThree[0]."\n";  
1390                                  $self->figmodel()->IntegrateGrowMatchSolution($self->id(),undef,$ReactionList,$DirectionList,"GAP FILLING",0,1);                                  $self->figmodel()->IntegrateGrowMatchSolution($self->id(),undef,$ReactionList,$DirectionList,"GAP FILLING",0,1);
1391                          }                          }
1392                          last;                          last;
# Line 1171  Line 1394 
1394          }          }
1395          #Updating model stats with gap filling results          #Updating model stats with gap filling results
1396          my $ElapsedTime = time() - $StartTime;          my $ElapsedTime = time() - $StartTime;
1397          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
1398          #Determining why each gap filling reaction was added          #Determining why each gap filling reaction was added
1399          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);          $self->figmodel()->IdentifyDependancyOfGapFillingReactions($self->id(),$Media);
1400          if (!defined($donotclear) || $donotclear != 1) {          if (!defined($donotclear) || $donotclear != 1) {
# Line 1191  Line 1414 
1414          return $self->success();          return $self->success();
1415  }  }
1416    
1417    =head3 GapGenModel
1418    Definition:
1419            FIGMODELmodel->GapGenModel();
1420    Description:
1421            Runs the gap generation algorithm to correct a single false positive prediction. Results are loaded into a table.
1422    =cut
1423    
1424    sub GapGenModel {
1425            my ($self,$Media,$KOList,$NoKOList,$Experiment,$SolutionLimit) = @_;
1426    
1427            #Enforcing nonoptional arguments
1428            if (!defined($Media)) {
1429                    return undef;
1430            }
1431            if (!defined($KOList)) {
1432                    $KOList->[0] = "none";
1433            }
1434            if (!defined($NoKOList)) {
1435                    $NoKOList->[0] = "none";
1436            }
1437            if (!defined($Experiment)) {
1438                    $Experiment= "ReactionKO";
1439            }
1440            if (!defined($SolutionLimit)) {
1441                    $SolutionLimit = "10";
1442            }
1443    
1444            #Translating the KO lists into arrays
1445            if (ref($KOList) ne "ARRAY") {
1446                    my $temp = $KOList;
1447                    $KOList = ();
1448                    push(@{$KOList},split(/[,;]/,$temp));
1449            }
1450            my $noKOHash;
1451            if (defined($NoKOList) && ref($NoKOList) ne "ARRAY") {
1452                    my $temp = $NoKOList;
1453                    $NoKOList = ();
1454                    push(@{$NoKOList},split(/[,;]/,$temp));
1455                    foreach my $rxn (@{$NoKOList}) {
1456                            $noKOHash->{$rxn} = 1;
1457                    }
1458            }
1459    
1460            #Checking if solutions exist for the input parameters
1461            $self->aquireModelLock();
1462            my $tbl = $self->load_model_table("GapGenSolutions");
1463            my $solutionRow = $tbl->get_table_by_key($Experiment,"Experiment")->get_table_by_key($Media,"Media")->get_row_by_key(join(",",@{$KOList}),"KOlist");
1464            my $solutions;
1465            if (defined($solutionRow)) {
1466                    #Checking if any solutions conform to the no KO list
1467                    foreach my $solution (@{$solutionRow->{Solutions}}) {
1468                            my @reactions = split(/,/,$solution);
1469                            my $include = 1;
1470                            foreach my $rxn (@reactions) {
1471                                    if ($rxn =~ m/(rxn\d\d\d\d\d)/) {
1472                                            if (defined($noKOHash->{$1})) {
1473                                                    $include = 0;
1474                                            }
1475                                    }
1476                            }
1477                            if ($include == 1) {
1478                                    push(@{$solutions},$solution);
1479                            }
1480                    }
1481            } else {
1482                    $solutionRow = {Media => [$Media],Experiment => [$Experiment],KOlist => [join(",",@{$KOList})]};
1483                    $tbl->add_row($solutionRow);
1484                    $self->figmodel()->database()->save_table($tbl);
1485            }
1486            $self->releaseModelLock();
1487    
1488            #Returning solution list of solutions were found
1489            if (defined($solutions) && @{$solutions} > 0) {
1490                    return $solutions;
1491            }
1492    
1493            #Getting unique filename
1494            my $Filename = $self->figmodel()->filename();
1495    
1496            #Running the gap generation
1497            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));
1498            my $ProblemReport = $self->figmodel()->LoadProblemReport($Filename);
1499            if (!defined($ProblemReport)) {
1500                    $self->figmodel()->error_message("FIGMODEL:GapGenerationAlgorithm;No problem report;".$Filename.";".$self->id().$self->selected_version().";".$Media.";".$KOList.";".$NoKOList);
1501                    return undef;
1502            }
1503    
1504            #Clearing the output folder and log file
1505            $self->figmodel()->clearing_output($Filename,"Gapgeneration-".$self->id().$self->selected_version()."-".$Filename.".log");
1506    
1507            #Saving the solution
1508            $self->aquireModelLock();
1509            $tbl = $self->load_model_table("GapGenSolutions");
1510            $solutionRow = $tbl->get_table_by_key($Experiment,"Experiment")->get_table_by_key($Media,"Media")->get_row_by_key(join(",",@{$KOList}),"KOlist");
1511            for (my $j=0; $j < $ProblemReport->size(); $j++) {
1512                    if ($ProblemReport->get_row($j)->{"Notes"}->[0] =~ m/^Recursive\sMILP\s([^)]+)/) {
1513                            my @SolutionList = split(/\|/,$1);
1514                            for (my $k=0; $k < @SolutionList; $k++) {
1515                                    if ($SolutionList[$k] =~ m/(\d+):(.+)/) {
1516                                            push(@{$solutionRow->{Solutions}},$2);
1517                                            push(@{$solutions},$2);
1518                                    }
1519                            }
1520                    }
1521            }
1522            $self->figmodel()->database()->save_table($tbl);
1523            $self->releaseModelLock();
1524    
1525            return $solutions;
1526    }
1527    
1528  =head3 datagapfill  =head3 datagapfill
1529  Definition:  Definition:
1530          success()/fail() = FIGMODELmodel->datagapfill();          success()/fail() = FIGMODELmodel->datagapfill();
# Line 1201  Line 1535 
1535          my ($self,$GapFillingRunSpecs,$TansferFileSuffix) = @_;          my ($self,$GapFillingRunSpecs,$TansferFileSuffix) = @_;
1536          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
1537          if (defined($GapFillingRunSpecs) && @{$GapFillingRunSpecs} > 0) {          if (defined($GapFillingRunSpecs) && @{$GapFillingRunSpecs} > 0) {
                 print "Gap filling specs:\n".join("\n",@{$GapFillingRunSpecs})."\n\n";  
1538                  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));
   
1539                  #Checking that the solution exists                  #Checking that the solution exists
1540                  if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt") {                  if (!-e $self->config("MFAToolkit output directory")->[0].$UniqueFilename."/GapFillingSolutionTable.txt") {
1541                          $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 1545 
1545                  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);
1546                  if (defined($TansferFileSuffix)) {                  if (defined($TansferFileSuffix)) {
1547                          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");  
1548                  }                  }
   
1549                  #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
1550                  $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");
1551                  return $GapFillingRunSpecs;                  return $GapFillResultTable;
1552          }          }
1553          if (defined($TansferFileSuffix)) {          if (defined($TansferFileSuffix)) {
1554                  $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 1614 
1614                          push(@{$DirectionArray},$SolutionHash{$ReactionList[$k]});                          push(@{$DirectionArray},$SolutionHash{$ReactionList[$k]});
1615                  }                  }
1616                  print "Integrating solution!\n";                  print "Integrating solution!\n";
1617                  $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);
1618                  my $model = $self->get_model($self->id().$TempVersion);                  $self->PrintModelLPFile();
                 $model->PrintModelLPFile();  
1619                  #Running the model against all available experimental data                  #Running the model against all available experimental data
1620                  print "Running test model!\n";                  print "Running test model!\n";
1621                  my ($FalsePostives,$FalseNegatives,$CorrectNegatives,$CorrectPositives,$Errorvector,$HeadingVector) = $self->RunAllStudiesWithDataFast("All");                  my ($FalsePostives,$FalseNegatives,$CorrectNegatives,$CorrectPositives,$Errorvector,$HeadingVector) = $self->RunAllStudiesWithDataFast("All");
# Line 1367  Line 1696 
1696  sub CreateSingleGenomeReactionList {  sub CreateSingleGenomeReactionList {
1697          my ($self,$RunGapFilling) = @_;          my ($self,$RunGapFilling) = @_;
1698    
1699            #Creating directory
1700            if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/") {
1701                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/");
1702            } elsif ($self->owner() eq "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->genome()."/") {
1703                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->genome()."/");
1704            }
1705            if ($self->owner() ne "master" && !-d $self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/") {
1706                    system("mkdir ".$self->figmodel()->config("organism directory")->[0].$self->owner()."/".$self->genome()."/");
1707            }
1708    
1709          #Getting genome stats          #Getting genome stats
1710          my $genomestats = $self->figmodel()->get_genome_stats($self->genome());          my $genomestats = $self->figmodel()->get_genome_stats($self->genome());
1711          my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());          my $FeatureTable = $self->figmodel()->GetGenomeFeatureTable($self->genome());
# Line 1702  Line 2041 
2041          $self->figmodel()->database()->save_table($NewModelTable);          $self->figmodel()->database()->save_table($NewModelTable);
2042          $self->{_reaction_data} = $NewModelTable;          $self->{_reaction_data} = $NewModelTable;
2043          #Clearing the previous model from the cache          #Clearing the previous model from the cache
2044          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
2045          #Updating the model stats table          #Updating the model stats table
2046          $self->update_stats_for_build();          $self->update_stats_for_build();
2047          $self->PrintSBMLFile();          $self->PrintSBMLFile();
# Line 1823  Line 2162 
2162          }          }
2163    
2164          #Clearing the previous model from the cache          #Clearing the previous model from the cache
2165          $self->figmodel()->ClearDBModel($self->id(),1);          $self->figmodel()->database()->ClearDBModel($self->id(),1);
2166          $ModelTable->save();          $ModelTable->save();
2167    
2168          return $self->success();          return $self->success();
# Line 1895  Line 2234 
2234          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
2235  =cut  =cut
2236  sub run_microarray_analysis {  sub run_microarray_analysis {
2237          my ($self,$media,$jobid,$index,$genecall) = @_;          my ($self,$media,$label,$index,$genecall) = @_;
2238          $genecall =~ s/_/:/g;          $genecall =~ s/_/:/g;
2239          $genecall =~ s/\//;/g;          $genecall =~ s/\//;/g;
2240          #print "\n\n".$genecall."\n\n";          my $uniqueFilename = $self->figmodel()->filename();
2241          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";  
2242          system($command);          system($command);
2243          #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";
2244        if (-e $filename) {
2245            my $output = $self->figmodel()->database()->load_single_column_file($filename);
2246            if (defined($output->[0])) {
2247                    my @array = split(/;/,$output->[0]);
2248                    $self->figmodel()->clearing_output($uniqueFilename,"MicroarrayAnalysis-".$uniqueFilename.".txt");
2249                    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]);
2250            }
2251            print STDERR $filename." is empty!";
2252        }
2253        print STDERR $filename." not found!";
2254        $self->figmodel()->clearing_output($uniqueFilename,"MicroarrayAnalysis-".$uniqueFilename.".txt");
2255    
2256            return undef;
2257  }  }
2258    
2259  =head3 find_minimal_pathways  =head3 find_minimal_pathways
# Line 1912  Line 2263 
2263          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
2264  =cut  =cut
2265  sub find_minimal_pathways {  sub find_minimal_pathways {
2266          my ($self,$media,$objective,$solutionnum) = @_;          my ($self,$media,$objective,$solutionnum,$AllReversible,$additionalexchange) = @_;
2267    
2268          #Setting default media          #Setting default media
2269          if (!defined($media)) {          if (!defined($media)) {
# Line 1924  Line 2275 
2275                  $solutionnum = "5";                  $solutionnum = "5";
2276          }          }
2277    
2278            #Setting additional exchange fluxes
2279            if (!defined($additionalexchange) || length($additionalexchange) == 0) {
2280                    if ($self->id() eq "iAF1260") {
2281                            $additionalexchange = "cpd03422[c]:-100:100;cpd01997[c]:-100:100;cpd11416[c]:-100:0;cpd15378[c]:-100:0;cpd15486[c]:-100:0";
2282                    } else {
2283                            $additionalexchange = $self->figmodel()->config("default exchange fluxes")->[0];
2284                    }
2285            }
2286    
2287          #Translating objective          #Translating objective
2288          my $objectivestring;          my $objectivestring;
2289          if ($objective eq "ALL") {          if ($objective eq "ALL") {
# Line 1944  Line 2304 
2304                          }                          }
2305                  }                  }
2306                  for (my $i=0; $i < @objectives; $i++) {                  for (my $i=0; $i < @objectives; $i++) {
2307                          $self->find_minimal_pathways($media,$objectives[$i])                          $self->find_minimal_pathways($media,$objectives[$i]);
2308                  }                  }
2309                    return;
2310          } elsif ($objective eq "ENERGY") {          } elsif ($objective eq "ENERGY") {
2311                  $objectivestring = "MAX;FLUX;rxn00062;c;1";                  $objectivestring = "MAX;FLUX;rxn00062;c;1";
2312          } elsif ($objective =~ m/cpd\d\d\d\d\d/) {          } elsif ($objective =~ m/cpd\d\d\d\d\d/) {
2313                    if ($objective =~ m/\[(\w)\]/) {
2314                            $objectivestring = "MIN;DRAIN_FLUX;".$objective.";".$1.";1";
2315                            $additionalexchange .= ";".$objective."[".$1."]:-100:0";
2316                    } else {
2317                  $objectivestring = "MIN;DRAIN_FLUX;".$objective.";c;1";                  $objectivestring = "MIN;DRAIN_FLUX;".$objective.";c;1";
2318                            $additionalexchange .= ";".$objective."[c]:-100:0";
2319                    }
2320            } elsif ($objective =~ m/(rxn\d\d\d\d\d)/) {
2321                    my ($Reactants,$Products) = $self->figmodel()->GetReactionSubstrateData($objective);
2322                    for (my $i=0; $i < @{$Products};$i++) {
2323                            my $temp = $Products->[$i]->{"DATABASE"}->[0];
2324                            if ($additionalexchange !~ m/$temp/) {
2325                                    #$additionalexchange .= ";".$temp."[c]:-100:0";
2326                            }
2327                    }
2328                    for (my $i=0; $i < @{$Reactants};$i++) {
2329                            print $Reactants->[$i]->{"DATABASE"}->[0]." started\n";
2330                            $self->find_minimal_pathways($media,$Reactants->[$i]->{"DATABASE"}->[0],$additionalexchange);
2331                            print $Reactants->[$i]->{"DATABASE"}->[0]." done\n";
2332                    }
2333                    return;
2334            }
2335    
2336            #Adding additional drains
2337            if (($objective eq "cpd15665" || $objective eq "cpd15667" || $objective eq "cpd15668" || $objective eq "cpd15669") && $additionalexchange !~ m/cpd15666/) {
2338                    $additionalexchange .= ";cpd15666[c]:0:100";
2339            } elsif ($objective eq "cpd11493" && $additionalexchange !~ m/cpd12370/) {
2340                    $additionalexchange .= ";cpd12370[c]:0:100";
2341            } elsif ($objective eq "cpd00166" && $additionalexchange !~ m/cpd01997/) {
2342                    $additionalexchange .= ";cpd01997[c]:0:100;cpd03422[c]:0:100";
2343            }
2344    
2345            #Running MFAToolkit
2346            my $filename = $self->figmodel()->filename();
2347            my $command;
2348            if (defined($AllReversible) && $AllReversible == 1) {
2349                    $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());
2350            } else {
2351                    $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());
2352            }
2353            system($command);
2354    
2355            #Loading problem report
2356            my $results = $self->figmodel()->LoadProblemReport($filename);
2357            #Clearing output
2358            $self->figmodel()->clearing_output($filename,"MinimalPathways-".$media."-".$self->id()."-".$objective.".txt");
2359            if (!defined($results)) {
2360                    print STDERR $objective." pathway results not found!\n";
2361                    return;
2362            }
2363    
2364            #Parsing output
2365            my @Array;
2366            my $row = $results->get_row(1);
2367            if (defined($row->{"Notes"}->[0])) {
2368                    $_ = $row->{"Notes"}->[0];
2369                    @Array = /\d+:([^\|]+)\|/g;
2370            }
2371    
2372            #Writing output to file
2373            $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join("|",@Array)]);
2374    }
2375    
2376    =head3 find_minimal_pathways
2377    Definition:
2378            int::status = FIGMODEL->find_minimal_pathways(string::media,string::objective);
2379    Description:
2380            Runs microarray analysis attempting to turn off genes that are inactive in the microarray
2381    =cut
2382    sub find_minimal_pathways_two {
2383            my ($self,$media,$objective,$solutionnum,$AllReversible,$additionalexchange) = @_;
2384    
2385            #Setting default media
2386            if (!defined($media)) {
2387                    $media = "Complete";
2388            }
2389    
2390            #Setting default solution number
2391            if (!defined($solutionnum)) {
2392                    $solutionnum = "5";
2393          }          }
2394    
2395          #Setting additional exchange fluxes          #Setting additional exchange fluxes
2396          my $additionalexchange = $self->config("default exchange fluxes")->[0];          if (!defined($additionalexchange) || length($additionalexchange) == 0) {
2397          if ($objective eq "cpd15665" || $objective eq "cpd15667" || $objective eq "cpd15668" || $objective eq "cpd15669") {                  if ($self->id() eq "iAF1260") {
2398                            $additionalexchange = "cpd03422[c]:-100:100;cpd01997[c]:-100:100;cpd11416[c]:-100:0;cpd15378[c]:-100:0;cpd15486[c]:-100:0";
2399                    } else {
2400                            $additionalexchange = $self->figmodel()->config("default exchange fluxes")->[0];
2401                    }
2402            }
2403    
2404            #Translating objective
2405            my $objectivestring;
2406            if ($objective eq "ALL") {
2407                    #Getting the list of universal building blocks
2408                    my $buildingblocks = $self->config("universal building blocks");
2409                    my @objectives = keys(%{$buildingblocks});
2410                    #Getting the nonuniversal building blocks
2411                    my $otherbuildingblocks = $self->config("nonuniversal building blocks");
2412                    my @array = keys(%{$otherbuildingblocks});
2413                    if (defined($self->get_biomass()) && defined($self->figmodel()->get_reaction($self->get_biomass()->{"LOAD"}->[0]))) {
2414                            my $equation = $self->figmodel()->get_reaction($self->get_biomass()->{"LOAD"}->[0])->{"EQUATION"}->[0];
2415                            if (defined($equation)) {
2416                                    for (my $i=0; $i < @array; $i++) {
2417                                            if (CORE::index($equation,$array[$i]) > 0) {
2418                                                    push(@objectives,$array[$i]);
2419                                            }
2420                                    }
2421                            }
2422                    }
2423                    for (my $i=0; $i < @objectives; $i++) {
2424                            $self->find_minimal_pathways($media,$objectives[$i]);
2425                    }
2426                    return;
2427            } elsif ($objective eq "ENERGY") {
2428                    $objectivestring = "MAX;FLUX;rxn00062;c;1";
2429            } elsif ($objective =~ m/cpd\d\d\d\d\d/) {
2430                    if ($objective =~ m/\[(\w)\]/) {
2431                            $objectivestring = "MIN;DRAIN_FLUX;".$objective.";".$1.";1";
2432                            $additionalexchange .= ";".$objective."[".$1."]:-100:0";
2433                    } else {
2434                            $objectivestring = "MIN;DRAIN_FLUX;".$objective.";c;1";
2435                            $additionalexchange .= ";".$objective."[c]:-100:0";
2436                    }
2437            } elsif ($objective =~ m/(rxn\d\d\d\d\d)/) {
2438                    my ($Reactants,$Products) = $self->figmodel()->GetReactionSubstrateData($objective);
2439                    for (my $i=0; $i < @{$Products};$i++) {
2440                            my $temp = $Products->[$i]->{"DATABASE"}->[0];
2441                            if ($additionalexchange !~ m/$temp/) {
2442                                    #$additionalexchange .= ";".$temp."[c]:-100:0";
2443                            }
2444                    }
2445                    for (my $i=0; $i < @{$Reactants};$i++) {
2446                            print $Reactants->[$i]->{"DATABASE"}->[0]." started\n";
2447                            $self->find_minimal_pathways($media,$Reactants->[$i]->{"DATABASE"}->[0],$additionalexchange);
2448                            print $Reactants->[$i]->{"DATABASE"}->[0]." done\n";
2449                    }
2450                    return;
2451            }
2452    
2453            #Adding additional drains
2454            if (($objective eq "cpd15665" || $objective eq "cpd15667" || $objective eq "cpd15668" || $objective eq "cpd15669") && $additionalexchange !~ m/cpd15666/) {
2455                  $additionalexchange .= ";cpd15666[c]:0:100";                  $additionalexchange .= ";cpd15666[c]:0:100";
2456          } elsif ($objective eq "cpd11493") {          } elsif ($objective eq "cpd11493" && $additionalexchange !~ m/cpd12370/) {
2457                  $additionalexchange .= ";cpd12370[c]:0:100";                  $additionalexchange .= ";cpd12370[c]:0:100";
2458          } elsif ($objective eq "cpd00166") {          } elsif ($objective eq "cpd00166" && $additionalexchange !~ m/cpd01997/) {
2459                  $additionalexchange .= ";cpd01997[c]:0:100;cpd03422[c]:0:100";                  $additionalexchange .= ";cpd01997[c]:0:100;cpd03422[c]:0:100";
2460          }          }
2461    
2462          #Running MFAToolkit          #Running MFAToolkit
2463          my $filename = $self->figmodel()->filename();          my $filename = $self->figmodel()->filename();
2464          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;
2465            if (defined($AllReversible) && $AllReversible == 1) {
2466                    $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());
2467            } else {
2468                    $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());
2469            }
2470            print $command."\n";
2471          system($command);          system($command);
2472    
2473          #Loading problem report          #Loading problem report
# Line 1972  Line 2475 
2475          #Clearing output          #Clearing output
2476          $self->figmodel()->clearing_output($filename,"MinimalPathways-".$media."-".$self->id()."-".$objective.".txt");          $self->figmodel()->clearing_output($filename,"MinimalPathways-".$media."-".$self->id()."-".$objective.".txt");
2477          if (!defined($results)) {          if (!defined($results)) {
2478                    print STDERR $objective." pathway results not found!\n";
2479                  return;                  return;
2480          }          }
2481    
# Line 1983  Line 2487 
2487                  @Array = /\d+:([^\|]+)\|/g;                  @Array = /\d+:([^\|]+)\|/g;
2488          }          }
2489    
2490          # Storing data in a figmodel table          #Writing output to file
2491          my $TableObject;          $self->figmodel()->database()->print_array_to_file($self->directory()."MinimalPathways-".$media."-".$objective."-".$self->id()."-".$AllReversible."-".$self->selected_version().".txt",[join("|",@Array)]);
2492          if (-e $self->directory()."MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt") {  }
2493                  $TableObject->load_table($self->directory()."MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",";","|",0,["OBJECTIVE"]);  
2494          } else {  sub combine_minimal_pathways {
2495                  $TableObject = FIGMODELTable->new(["OBJECTIVE","REACTIONS"],$self->directory()."MinimalPathways-".$media."-".$self->id().$self->selected_version().".txt",["OBJECTIVE"],";","|",undef);          my ($self) = @_;
2496          }  
2497          my $tablerow = $TableObject->get_row_by_key($objective,"OBJECTIVE",1);          my $tbl;
2498          push(@{$tablerow->{"REACTIONS"}},@Array);          if (-e $self->directory()."MinimalPathwayTable-".$self->id().$self->selected_version().".tbl") {
2499          $TableObject->save();                  $tbl = FIGMODELTable::load_table($self->directory()."MinimalPathwayTable-".$self->id().$self->selected_version().".tbl",";","|",0,["Objective","Media","Reversible"]);
2500            } else {
2501                    $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"],";","|");
2502            }
2503            my @files = glob($self->directory()."MinimalPathways-*");
2504            for (my $i=0; $i < @files;$i++) {
2505                    if ($files[$i] =~ m/MinimalPathways\-(\S+)\-(cpd\d\d\d\d\d)\-(\w+)\-(\d)\-/ || $files[$i] =~ m/MinimalPathways\-(\S+)\-(ENERGY)\-(\w+)\-(\d)\-/) {
2506                            my $reactions = $self->figmodel()->database()->load_single_column_file($files[$i],"");
2507                            if (defined($reactions) && @{$reactions} > 0 && length($reactions->[0]) > 0) {
2508                                    my $newrow = {"Objective"=>[$2],"Media"=>[$1],"Reversible"=>[$4]};
2509                                    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");
2510                                    if (!defined($row)) {
2511                                            $row = $tbl->add_row($newrow);
2512                                    }
2513                                    $row->{Reactions} = $self->figmodel()->database()->load_single_column_file($files[$i],"");
2514                                    delete($row->{"Shortest path"});
2515                                    delete($row->{"Number of essentials"});
2516                                    delete($row->{"Essentials"});
2517                                    delete($row->{"Length"});
2518                                    for (my $j=0; $j < @{$row->{Reactions}}; $j++) {
2519                                            my @array = split(/,/,$row->{Reactions}->[$j]);
2520                                            $row->{"Length"}->[$j] = @array;
2521                                            if (!defined($row->{"Shortest path"}->[0]) || $row->{"Length"}->[$j] < $row->{"Shortest path"}->[0]) {
2522                                                    $row->{"Shortest path"}->[0] = $row->{"Length"}->[$j];
2523                                            }
2524                                            $row->{"Number of essentials"}->[0] = 0;
2525                                            for (my $k=0; $k < @array;$k++) {
2526                                                    if ($array[$k] =~ m/(rxn\d\d\d\d\d)/) {
2527                                                            my $class = $self->get_reaction_class($1,1);
2528                                                            my $temp = $row->{Media}->[0].":Essential";
2529                                                            if ($class =~ m/$temp/) {
2530                                                                    $row->{"Number of essentials"}->[$j]++;
2531                                                                    if (!defined($row->{"Essentials"}->[$j]) && length($row->{"Essentials"}->[$j]) > 0) {
2532                                                                            $row->{"Essentials"}->[$j] = $array[$k];
2533                                                                    } else {
2534                                                                            $row->{"Essentials"}->[$j] .= ",".$array[$k];
2535                                                                    }
2536                                                            }
2537                                                    }
2538                                            }
2539                                    }
2540                            }
2541                    }
2542            }
2543            $tbl->save();
2544  }  }
2545    
2546  =head3 calculate_growth  =head3 calculate_growth
# Line 2036  Line 2584 
2584          7.) Dead: these reactions are disconnected from the network.          7.) Dead: these reactions are disconnected from the network.
2585  =cut  =cut
2586  sub classify_model_reactions {  sub classify_model_reactions {
2587          my ($self,$Media) = @_;          my ($self,$Media,$SaveChanges) = @_;
2588    
2589          #Getting unique file for printing model output          #Getting unique file for printing model output
2590          my $UniqueFilename = $self->figmodel()->filename();          my $UniqueFilename = $self->figmodel()->filename();
# Line 2123  Line 2671 
2671                                  $CpdRow->{MEDIA}->[$index] = $Media;                                  $CpdRow->{MEDIA}->[$index] = $Media;
2672                          }                          }
2673                  }                  }
2674                    if (!defined($SaveChanges) || $SaveChanges == 1) {
2675                  $cpdclasstable->save();                  $cpdclasstable->save();
2676          }          }
2677            }
2678          if (defined($ReactionTB)) {          if (defined($ReactionTB)) {
2679                  for (my $i=0; $i < $ReactionTB->size(); $i++) {                  for (my $i=0; $i < $ReactionTB->size(); $i++) {
2680                          my $Row = $ReactionTB->get_row($i);                          my $Row = $ReactionTB->get_row($i);
# Line 2179  Line 2729 
2729                                  $RxnRow->{MEDIA}->[$index] = $Media;                                  $RxnRow->{MEDIA}->[$index] = $Media;
2730                          }                          }
2731                  }                  }
2732                    if (!defined($SaveChanges) || $SaveChanges == 1) {
2733                  $rxnclasstable->save();                  $rxnclasstable->save();
2734          }          }
2735            }
2736          return ($rxnclasstable,$cpdclasstable);          return ($rxnclasstable,$cpdclasstable);
2737  }  }
2738    
# Line 2212  Line 2764 
2764    
2765          #Running simulations          #Running simulations
2766          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";  
2767          #Parsing the results          #Parsing the results
2768          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);
2769          if (!defined($Results)) {          if (!defined($Results)) {
# Line 2619  Line 3170 
3170                                          if (length($GapFillingRunSpecs) > 0) {                                          if (length($GapFillingRunSpecs) > 0) {
3171                                                  $GapFillingRunSpecs .= ";";                                                  $GapFillingRunSpecs .= ";";
3172                                          }                                          }
3173                                          $GapFillingRunSpecs .= $HeadingDataArray[2].":".$HeadingDataArray[1].".txt:".$HeadingDataArray[3];                                          $GapFillingRunSpecs .= $HeadingDataArray[2].":".$HeadingDataArray[1].":".$HeadingDataArray[3];
3174                                  } else {                                  } else {
3175                                          $SolutionExistedCount++;                                          $SolutionExistedCount++;
3176                                  }                                  }
# Line 2644  Line 3195 
3195          my $SolutionsFound = 0;          my $SolutionsFound = 0;
3196          my $GapFillingArray;          my $GapFillingArray;
3197          push(@{$GapFillingArray},split(/;/,$GapFillingRunSpecs));          push(@{$GapFillingArray},split(/;/,$GapFillingRunSpecs));
3198          $self->datagapfill($GapFillingArray);          my $GapFillingResults = $self->datagapfill($GapFillingArray,"GFS");
3199            if (defined($GapFillingResults)) {
3200                    $SolutionsFound = 1;
3201            }
3202    
3203          if (defined($RescuedPreviousResults) && @{$RescuedPreviousResults} > 0) {          if (defined($RescuedPreviousResults) && @{$RescuedPreviousResults} > 0) {
3204                  #Printing previous solutions to GFS file                  #Printing previous solutions to GFS file
# Line 2667  Line 3221 
3221          return $self->success();          return $self->success();
3222  }  }
3223    
3224    =head3 SolutionReconciliation
3225    Definition:
3226            FIGMODELmodel->SolutionReconciliation();
3227    Description:
3228            This is a wrapper for running the solution reconciliation algorithm on any model in the database.
3229            The algorithm performs a reconciliation of any gap filling solutions to identify the combination of solutions that results in the optimal model.
3230            This function prints out one output file in the Model directory: ReconciliationOutput.txt: this is a summary of the results of the reconciliation analysis
3231    =cut
3232    
3233    sub SolutionReconciliation {
3234            my ($self,$GapFill,$Stage) = @_;
3235    
3236            #Setting the output filenames
3237            my $OutputFilename;
3238            my $OutputFilenameTwo;
3239            if ($GapFill == 1) {
3240                    $OutputFilename = $self->directory().$self->id().$self->selected_version()."-GFReconciliation.txt";
3241                    $OutputFilenameTwo = $self->directory().$self->id().$self->selected_version()."-GFSRS.txt";
3242            } else {
3243                    $OutputFilename = $self->directory().$self->id().$self->selected_version()."-GGReconciliation.txt";
3244                    $OutputFilenameTwo = $self->directory().$self->id().$self->selected_version()."-GGSRS.txt";
3245            }
3246    
3247            #In stage one, we run the reconciliation and create a test file to check combined solution performance
3248            if (!defined($Stage) || $Stage == 1) {
3249                    my $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3250                    my $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3251                    $Row->{"GF RECONCILATION TIMING"}->[0] = time()."-";
3252                    $GrowMatchTable->save();
3253                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3254    
3255                    #Getting a unique filename
3256                    my $UniqueFilename = $self->figmodel()->filename();
3257    
3258                    #Copying over the necessary files
3259                    if ($GapFill == 1) {
3260                            if (!-e $self->directory().$self->id().$self->selected_version()."-GFEM.txt") {
3261                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-GFEM.txt file not found. Could not reconcile!";
3262                                    return 0;
3263                            }
3264                            if (!-e $self->directory().$self->id().$self->selected_version()."-OPEM.txt") {
3265                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-OPEM.txt file not found. Could not reconcile!";
3266                                    return 0;
3267                            }
3268                            system("cp ".$self->directory().$self->id().$self->selected_version()."-GFEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-GFEM.txt");
3269                            system("cp ".$self->directory().$self->id().$self->selected_version()."-OPEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-OPEM.txt");
3270                            #Backing up and deleting the existing reconciliation file
3271                            if (-e $OutputFilename) {
3272                                    system("cp ".$OutputFilename." ".$self->directory().$self->id().$self->selected_version()."-OldGFReconciliation.txt");
3273                                    unlink($OutputFilename);
3274                            }
3275                    } else {
3276                            if (!-e $self->directory().$self->id().$self->selected_version()."-GGEM.txt") {
3277                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-GGEM.txt file not found. Could not reconcile!";
3278                                    return 0;
3279                            }
3280                            if (!-e $self->directory().$self->id().$self->selected_version()."-GGOPEM.txt") {
3281                                    print STDERR "FIGMODEL:SolutionReconciliation:".$self->directory().$self->id().$self->selected_version()."-GGOPEM.txt file not found. Could not reconcile!";
3282                                    return 0;
3283                            }
3284                            system("cp ".$self->directory().$self->id().$self->selected_version()."-GGEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-GGEM.txt");
3285                            system("cp ".$self->directory().$self->id().$self->selected_version()."-GGOPEM.txt ".$self->figmodel()->config("MFAToolkit input files")->[0].$UniqueFilename."-OPEM.txt");
3286                            #Backing up and deleting the existing reconciliation file
3287                            if (-e $OutputFilename) {
3288                                    system("cp ".$OutputFilename." ".$self->directory().$self->id().$self->selected_version()."-OldGGReconciliation.txt");
3289                                    unlink($OutputFilename);
3290                            }
3291                    }
3292    
3293                    #Running the reconciliation
3294                    system($self->figmodel()->GenerateMFAToolkitCommandLineCall($UniqueFilename,$self->id(),"NONE",["SolutionReconciliation"],{"Solution data for model optimization" => $UniqueFilename},"Reconciliation".$UniqueFilename.".log",undef,$self->selected_version()));
3295                    $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3296                    $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3297                    $Row->{"GF RECONCILATION TIMING"}->[0] .= time();
3298                    $GrowMatchTable->save();
3299                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3300    
3301                    #Loading the problem report from the reconciliation run
3302                    my $ReconciliatonOutput = $self->figmodel()->LoadProblemReport($UniqueFilename);
3303                    print $UniqueFilename."\n";
3304                    #Clearing output files
3305                    $self->figmodel()->clearing_output($UniqueFilename,"Reconciliation".$UniqueFilename.".log");
3306                    $ReconciliatonOutput->save("/home/chenry/Test.txt");
3307    
3308                    #Checking the a problem report was found and was loaded
3309                    if (!defined($ReconciliatonOutput) || $ReconciliatonOutput->size() < 1 || !defined($ReconciliatonOutput->get_row(0)->{"Notes"}->[0])) {
3310                            print STDERR "FIGMODEL:SolutionReconciliation: MFAToolkit output from SolutionReconciliation of ".$self->id()." not found!\n\n";
3311                            return 0;
3312                    }
3313    
3314                    #Processing the solutions
3315                    my $SolutionCount = 0;
3316                    my $ReactionSetHash;
3317                    my $SingleReactionHash;
3318                    my $ReactionDataHash;
3319                    for (my $n=0; $n < $ReconciliatonOutput->size(); $n++) {
3320                            if (defined($ReconciliatonOutput->get_row($n)->{"Notes"}->[0]) && $ReconciliatonOutput->get_row($n)->{"Notes"}->[0] =~ m/^Recursive\sMILP\s([^;]+)/) {
3321                                    #Breaking up the solution into reaction sets
3322                                    my @ReactionSets = split(/\|/,$1);
3323                                    #Creating reaction lists for each set
3324                                    my $SolutionHash;
3325                                    for (my $i=0; $i < @ReactionSets; $i++) {
3326                                            if (length($ReactionSets[$i]) > 0) {
3327                                                    my @Alternatives = split(/:/,$ReactionSets[$i]);
3328                                                    for (my $j=1; $j < @Alternatives; $j++) {
3329                                                            if (length($Alternatives[$j]) > 0) {
3330                                                                    push(@{$SolutionHash->{$Alternatives[$j]}},$Alternatives[0]);
3331                                                            }
3332                                                    }
3333                                                    if (@Alternatives == 1) {
3334                                                            $SingleReactionHash->{$Alternatives[0]}->{$SolutionCount} = 1;
3335                                                            if (!defined($SingleReactionHash->{$Alternatives[0]}->{"COUNT"})) {
3336                                                                    $SingleReactionHash->{$Alternatives[0]}->{"COUNT"} = 0;
3337                                                            }
3338                                                            $SingleReactionHash->{$Alternatives[0]}->{"COUNT"}++;
3339                                                    }
3340                                            }
3341                                    }
3342                                    #Identifying reactions sets and storing the sets in the reactions set hash
3343                                    foreach my $Solution (keys(%{$SolutionHash})) {
3344                                            my $SetKey = join(",",sort(@{$SolutionHash->{$Solution}}));
3345                                            if (!defined($ReactionSetHash->{$SetKey}->{$SetKey}->{$SolutionCount})) {
3346                                                    $ReactionSetHash->{$SetKey}->{$SetKey}->{$SolutionCount} = 1;
3347                                                    if (!defined($ReactionSetHash->{$SetKey}->{$SetKey}->{"COUNT"})) {
3348                                                            $ReactionSetHash->{$SetKey}->{$SetKey}->{"COUNT"} = 0;
3349                                                    }
3350                                                    $ReactionSetHash->{$SetKey}->{$SetKey}->{"COUNT"}++;
3351                                            }
3352                                            $ReactionSetHash->{$SetKey}->{$Solution}->{$SolutionCount} = 1;
3353                                            if (!defined($ReactionSetHash->{$SetKey}->{$Solution}->{"COUNT"})) {
3354                                                    $ReactionSetHash->{$SetKey}->{$Solution}->{"COUNT"} = 0;
3355                                            }
3356                                            $ReactionSetHash->{$SetKey}->{$Solution}->{"COUNT"}++;
3357                                    }
3358                                    $SolutionCount++;
3359                            }
3360                    }
3361    
3362                    #Handling the scenario where no solutions were found
3363                    if ($SolutionCount == 0) {
3364                            print STDERR "FIGMODEL:SolutionReconciliation: Reconciliation unsuccessful. No solution found.\n\n";
3365                            return 0;
3366                    }
3367    
3368                    #Printing results without solution performance figures. Also printing solution test file
3369                    open (RECONCILIATION, ">$OutputFilename");
3370                    #Printing the file heading
3371                    print RECONCILIATION "DATABASE;DEFINITION;REVERSIBLITY;DELTAG;DIRECTION;NUMBER OF SOLUTIONS";
3372                    for (my $i=0; $i < $SolutionCount; $i++) {
3373                            print RECONCILIATION ";Solution ".$i;
3374                    }
3375                    print RECONCILIATION "\n";
3376                    #Printing the singlet reactions first
3377                    my $Solutions;
3378                    print RECONCILIATION "SINGLET REACTIONS\n";
3379                    my @SingletReactions = keys(%{$SingleReactionHash});
3380                    for (my $j=0; $j < $SolutionCount; $j++) {
3381                            $Solutions->[$j]->{"BASE"} = $j;
3382                    }
3383                    for (my $i=0; $i < @SingletReactions; $i++) {
3384                            my $ReactionData;
3385                            if (defined($ReactionDataHash->{$SingletReactions[$i]})) {
3386                                    $ReactionData = $ReactionDataHash->{$SingletReactions[$i]};
3387                            } else {
3388                                    my $Direction = substr($SingletReactions[$i],0,1);
3389                                    if ($Direction eq "+") {
3390                                            $Direction = "=>";
3391                                    } else {
3392                                            $Direction = "<=";
3393                                    }
3394                                    my $Reaction = substr($SingletReactions[$i],1);
3395                                    $ReactionData = FIGMODELObject->load($self->figmodel()->config("reaction directory")->[0].$Reaction,"\t");
3396                                    $ReactionData->{"DIRECTIONS"}->[0] = $Direction;
3397                                    $ReactionData->{"REACTIONS"}->[0] = $Reaction;
3398                                    if (!defined($ReactionData->{"DEFINITION"}->[0])) {
3399                                            $ReactionData->{"DEFINITION"}->[0] = "UNKNOWN";
3400                                    }
3401                                    if (!defined($ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0])) {
3402                                            $ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0] = "UNKNOWN";
3403                                    }
3404                                    if (!defined($ReactionData->{"DELTAG"}->[0])) {
3405                                            $ReactionData->{"DELTAG"}->[0] = "UNKNOWN";
3406                                    }
3407                                    $ReactionDataHash->{$SingletReactions[$i]} = $ReactionData;
3408                            }
3409                            print RECONCILIATION $ReactionData->{"REACTIONS"}->[0].";".$ReactionData->{"DEFINITION"}->[0].";".$ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0].";".$ReactionData->{"DELTAG"}->[0].";".$ReactionData->{"DIRECTIONS"}->[0].";".$SingleReactionHash->{$SingletReactions[$i]}->{"COUNT"};
3410                            for (my $j=0; $j < $SolutionCount; $j++) {
3411                                    print RECONCILIATION ";";
3412                                    if (defined($SingleReactionHash->{$SingletReactions[$i]}->{$j})) {
3413                                            $Solutions->[$j]->{$SingletReactions[$i]} = 1;
3414                                            $Solutions->[$j]->{"BASE"} = $j;
3415                                            print RECONCILIATION "|".$j."|";
3416                                    }
3417                            }
3418                            print RECONCILIATION "\n";
3419                    }
3420                    #Printing the reaction sets with alternatives
3421                    print RECONCILIATION "Reaction sets with alternatives\n";
3422                    my @ReactionSets = keys(%{$ReactionSetHash});
3423                    foreach my $ReactionSet (@ReactionSets) {
3424                            my $NewSolutions;
3425                            my $BaseReactions;
3426                            my $AltList = [$ReactionSet];
3427                            push(@{$AltList},keys(%{$ReactionSetHash->{$ReactionSet}}));
3428                            for (my $j=0; $j < @{$AltList}; $j++) {
3429                                    my $CurrentNewSolutions;
3430                                    my $Index;
3431                                    if ($j == 0) {
3432                                            print RECONCILIATION "NEW SET\n";
3433                                    } elsif ($AltList->[$j] ne $ReactionSet) {
3434                                            print RECONCILIATION "ALTERNATIVE SET\n";
3435                                            #For each base solution in which this set is represented, we copy the base solution to the new solution
3436                                            my $NewSolutionCount = 0;
3437                                            for (my $k=0; $k < $SolutionCount; $k++) {
3438                                                    if (defined($ReactionSetHash->{$ReactionSet}->{$AltList->[$j]}->{$k})) {
3439                                                            if (defined($Solutions)) {
3440                                                                    $Index->{$k} = @{$Solutions} + $NewSolutionCount;
3441                                                            } else {
3442                                                                    $Index->{$k} = $NewSolutionCount;
3443                                                            }
3444                                                            if (defined($NewSolutions) && @{$NewSolutions} > 0) {
3445                                                                    $Index->{$k} += @{$NewSolutions};
3446                                                            }
3447                                                            $CurrentNewSolutions->[$NewSolutionCount] = {};
3448                                                            foreach my $Reaction (keys(%{$Solutions->[$k]})) {
3449                                                                    $CurrentNewSolutions->[$NewSolutionCount]->{$Reaction} = $Solutions->[$k]->{$Reaction};
3450                                                            }
3451                                                            $NewSolutionCount++;
3452                                                    }
3453                                            }
3454                                    }
3455                                    if ($j == 0 || $AltList->[$j] ne $ReactionSet) {
3456                                            my @SingletReactions = split(/,/,$AltList->[$j]);
3457                                            for (my $i=0; $i < @SingletReactions; $i++) {
3458                                                    #Adding base reactions to base solutions and set reactions the new solutions
3459                                                    if ($j == 0) {
3460                                                            push(@{$BaseReactions},$SingletReactions[$i]);
3461                                                    } else {
3462                                                            for (my $k=0; $k < @{$CurrentNewSolutions}; $k++) {
3463                                                                    $CurrentNewSolutions->[$k]->{$SingletReactions[$i]} = 1;
3464                                                            }
3465                                                    }
3466                                                    #Getting reaction data and printing reaction in output file
3467                                                    my $ReactionData;
3468                                                    if (defined($ReactionDataHash->{$SingletReactions[$i]})) {
3469                                                            $ReactionData = $ReactionDataHash->{$SingletReactions[$i]};
3470                                                    } else {
3471                                                            my $Direction = substr($SingletReactions[$i],0,1);
3472                                                            if ($Direction eq "+") {
3473                                                                    $Direction = "=>";
3474                                                            } else {
3475                                                                    $Direction = "<=";
3476                                                            }
3477                                                            my $Reaction = substr($SingletReactions[$i],1);
3478                                                            $ReactionData = FIGMODELObject->load($self->figmodel()->config("reaction directory")->[0].$Reaction,"\t");
3479                                                            $ReactionData->{"DIRECTIONS"}->[0] = $Direction;
3480                                                            $ReactionData->{"REACTIONS"}->[0] = $Reaction;
3481                                                            if (!defined($ReactionData->{"DEFINITION"}->[0])) {
3482                                                                    $ReactionData->{"DEFINITION"}->[0] = "UNKNOWN";
3483                                                            }
3484                                                            if (!defined($ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0])) {
3485                                                                    $ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0] = "UNKNOWN";
3486                                                            }
3487                                                            if (!defined($ReactionData->{"DELTAG"}->[0])) {
3488                                                                    $ReactionData->{"DELTAG"}->[0] = "UNKNOWN";
3489                                                            }
3490                                                            $ReactionDataHash->{$SingletReactions[$i]} = $ReactionData;
3491                                                    }
3492                                                    print RECONCILIATION $ReactionData->{"REACTIONS"}->[0].";".$ReactionData->{"DEFINITION"}->[0].";".$ReactionData->{"THERMODYNAMIC REVERSIBILITY"}->[0].";".$ReactionData->{"DELTAG"}->[0].";".$ReactionData->{"DIRECTIONS"}->[0].";".$ReactionSetHash->{$ReactionSet}->{$AltList->[$j]}->{"COUNT"};
3493                                                    for (my $k=0; $k < $SolutionCount; $k++) {
3494                                                            print RECONCILIATION ";";
3495                                                            if (defined($ReactionSetHash->{$ReactionSet}->{$AltList->[$j]}->{$k})) {
3496                                                                    if ($j == 0) {
3497                                                                            print RECONCILIATION "|".$k."|";
3498                                                                    } else {
3499                                                                            print RECONCILIATION "|".$Index->{$k}."|";
3500                                                                    }
3501                                                            }
3502                                                    }
3503                                                    print RECONCILIATION "\n";
3504                                            }
3505                                            #Adding the current new solutions to the new solutions array
3506                                            if (defined($CurrentNewSolutions) && @{$CurrentNewSolutions} > 0) {
3507                                                    push(@{$NewSolutions},@{$CurrentNewSolutions});
3508                                            }
3509                                    }
3510                            }
3511                            #Adding the base reactions to all existing solutions
3512                            for (my $j=0; $j < @{$Solutions}; $j++) {
3513                                    if (defined($ReactionSetHash->{$ReactionSet}->{$ReactionSet}->{$Solutions->[$j]->{"BASE"}})) {
3514                                            foreach my $SingleReaction (@{$BaseReactions}) {
3515                                                    $Solutions->[$j]->{$SingleReaction} = 1;
3516                                            }
3517                                    }
3518                            }
3519                            #Adding the new solutions to the set of existing solutions
3520                            push(@{$Solutions},@{$NewSolutions});
3521                    }
3522                    close(RECONCILIATION);
3523                    #Now printing a file that defines all of the solutions in a format the testsolutions function understands
3524                    open (RECONCILIATION, ">$OutputFilenameTwo");
3525                    print RECONCILIATION "Experiment;Solution index;Solution cost;Solution reactions\n";
3526                    for (my $i=0; $i < @{$Solutions}; $i++) {
3527                            delete($Solutions->[$i]->{"BASE"});
3528                            print RECONCILIATION "SR".$i.";".$i.";10;".join(",",keys(%{$Solutions->[$i]}))."\n";
3529                    }
3530                    close(RECONCILIATION);
3531    
3532                    $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3533                    $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3534                    $Row->{"GF RECON TESTING TIMING"}->[0] = time()."-";
3535                    $Row->{"GF RECON SOLUTIONS"}->[0] = @{$Solutions};
3536                    $GrowMatchTable->save();
3537                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3538    
3539                    #Scheduling the solution testing
3540                    if ($GapFill == 1) {
3541                            system($self->figmodel()->config("scheduler executable")->[0]." \"add:testsolutions?".$self->id().$self->selected_version()."?-1?GFSR:BACK:fast:QSUB\"");
3542                    } else {
3543                            system($self->figmodel()->config("scheduler executable")->[0]." \"add:testsolutions?".$self->id().$self->selected_version()."?-1?GGSR:BACK:fast:QSUB\"");
3544                    }
3545            } else {
3546                    #Reading in the solution testing results
3547                    my $Data;
3548                    if ($GapFill == 1) {
3549                            $Data = $self->figmodel()->database()->load_single_column_file($self->directory().$self->id().$self->selected_version()."-GFSREM.txt","");
3550                    } else {
3551                            $Data = $self->figmodel()->database()->load_single_column_file($self->directory().$self->id().$self->selected_version()."-GGSREM.txt","");
3552                    }
3553    
3554                    #Reading in the preliminate reconciliation report
3555                    my $OutputData = $self->figmodel()->database()->load_single_column_file($OutputFilename,"");
3556                    #Replacing the file tags with actual performance data
3557                    my $Count = 0;
3558                    for (my $i=0; $i < @{$Data}; $i++) {
3559                            if ($Data->[$i] =~ m/^SR(\d+);.+;(\d+\/\d+);/) {
3560                                    my $Index = $1;
3561                                    my $Performance = $Index."/".$2;
3562                                    for (my $j=0; $j < @{$OutputData}; $j++) {
3563                                            $OutputData->[$j] =~ s/\|$Index\|/$Performance/g;
3564                                    }
3565                            }
3566                    }
3567                    $self->figmodel()->database()->print_array_to_file($OutputFilename,$OutputData);
3568    
3569                    my $GrowMatchTable = $self->figmodel()->database()->LockDBTable("GROWMATCH TABLE");
3570                    my $Row = $GrowMatchTable->get_row_by_key($self->genome(),"ORGANISM",1);
3571                    $Row->{"GF RECON TESTING TIMING"}->[0] .= time();
3572                    $GrowMatchTable->save();
3573                    $self->figmodel()->database()->UnlockDBTable("GROWMATCH TABLE");
3574            }
3575    
3576            return 1;
3577    }
3578    
3579  =head3 BuildSpecificBiomassReaction  =head3 BuildSpecificBiomassReaction
3580  Definition:  Definition:
3581          FIGMODELmodel->BuildSpecificBiomassReaction();          FIGMODELmodel->BuildSpecificBiomassReaction();
# Line 3287  Line 4196 
4196          $self->figmodel()->clearing_output($UniqueFilename,"FBA-".$self->id().$self->selected_version().".lp");          $self->figmodel()->clearing_output($UniqueFilename,"FBA-".$self->id().$self->selected_version().".lp");
4197  }  }
4198    
4199    =head3 patch_model
4200    Definition:
4201            FIGMODELTable:patch results = FIGMODELmodel->patch_model(FIGMODELTable:patch table);
4202    Description:
4203    =cut
4204    sub patch_model {
4205            my ($self,$tbl) = @_;
4206    
4207            #Instantiating table
4208            my $results = FIGMODELTable->new(["Reactions","New genes","Old genes","Genes","Roles","Status"],$self->directory()."PatchResults-".$self->id().$self->selected_version().".tbl",["Reaction"],"\t",";",undef);
4209            #Getting genome annotations
4210            my $features = $self->figmodel()->database()->get_genome_feature_table($self->genome());
4211            #Gettubg reaction table
4212            my $reactions = $self->reaction_table();
4213            #Checking for patched roles
4214            for (my $i=0; $i < $tbl->size(); $i++) {
4215                    my $row = $tbl->get_row($i);
4216                    my @genes = $features->get_rows_by_key($row->{ROLE}->[0],"ROLES");
4217                    if (@genes > 0) {
4218                            for (my $j=0; $j < @{$row->{REACTIONS}};$j++) {
4219                                    my $resultrxn = $results->get_row_by_key($row->{REACTIONS}->[$j],"Reactions");
4220                                    if (!defined($resultrxn)) {
4221                                            $resultrxn = $results->add_row({"Reactions"=>[$row->{REACTIONS}->[$j]],"Roles"=>[$row->{ROLE}->[0]]});
4222                                    }
4223                                    my $rxnrow = $reactions->get_row_by_key($row->{REACTIONS}->[$j],"LOAD");
4224                                    if (defined($rxnrow) && !defined($resultrxn->{"Old genes"})) {
4225                                            $resultrxn->{"Old genes"} = $rxnrow->{"ASSOCIATED PEG"};
4226                                            if ($resultrxn->{"Old genes"}->[0] !~ m/GAP|BOF|UNIVERSAL|SPONTANEOUS/) {
4227                                                    push(@{$resultrxn->{"Genes"}},@{$resultrxn->{"Old genes"}});
4228                                            }
4229                                    }
4230                                    delete $resultrxn->{"Current gene set"};
4231                                    if (defined($resultrxn->{"Genes"})) {
4232                                            push(@{$resultrxn->{"Current gene set"}},@{$resultrxn->{"Genes"}});
4233                                    }
4234                                    for (my $k=0; $k < @genes; $k++) {
4235                                            if ($genes[$k]->{ID}->[0] =~ m/(peg\.\d+)/) {
4236                                                    my $gene = $1;
4237                                                    my $addgene = 1;
4238                                                    if (defined($resultrxn->{"Old genes"})) {
4239                                                            for (my $m=0; $m < @{$resultrxn->{"Old genes"}}; $m++) {
4240                                                                    if ($resultrxn->{"Old genes"}->[$m] =~ m/$gene/) {
4241                                                                            $addgene = 0;
4242                                                                    }
4243                                                            }
4244                                                    }
4245                                                    if ($addgene == 1) {
4246                                                            push(@{$resultrxn->{"New genes"}},$gene);
4247                                                            if ($row->{COMPLEX}->[0] ne "0" && defined($resultrxn->{"Current gene set"})) {
4248                                                                    my $added = 0;
4249                                                                    for (my $m=0; $m < @{$resultrxn->{"Current gene set"}}; $m++) {
4250                                                                            if ($row->{COMPLEX}->[0] eq "1") {
4251                                                                                    $resultrxn->{"Current gene set"}->[$m] = $resultrxn->{"Current gene set"}->[$m]."+".$gene;
4252                                                                                    $added = 1;
4253                                                                            } else {
4254                                                                                    my @geneset = split(/\+/,$resultrxn->{"Current gene set"}->[$m]);
4255                                                                                    for (my $n=0; $n < @geneset;$n++) {
4256                                                                                            if ($self->figmodel()->colocalized_genes($geneset[$n],$gene,$self->genome()) == 1) {
4257                                                                                                    $resultrxn->{"Current gene set"}->[$m] = $resultrxn->{"Current gene set"}->[$m]."+".$gene;
4258                                                                                                    $added = 1;
4259                                                                                                    last;
4260                                                                                            }
4261                                                                                    }
4262                                                                            }
4263                                                                    }
4264                                                                    if ($added == 0) {
4265                                                                            push(@{$resultrxn->{"Current gene set"}},$gene);
4266                                                                    }
4267                                                            } else {
4268                                                                    push(@{$resultrxn->{"Current gene set"}},$gene);
4269                                                            }
4270                                                    }
4271                                            }
4272                                    }
4273                                    delete $resultrxn->{"Genes"};
4274                                    push(@{$resultrxn->{"Genes"}},@{$resultrxn->{"Current gene set"}});
4275                            }
4276                    }
4277            }
4278    
4279            #Ensuring that the old model is preserved
4280            $self->ArchiveModel();
4281            #Modifing the reaction list
4282            for (my $i=0; $i < $results->size();$i++) {
4283                    my $row = $results->get_row($i);
4284                    my $rxnrow = $reactions->get_row_by_key($row->{"Reactions"}->[0],"LOAD");
4285                    if (defined($rxnrow)) {
4286                            $rxnrow->{"ASSOCIATED PEG"} = $row->{"Genes"};
4287                    } else {
4288                            $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"]});
4289                    }
4290            }
4291            $reactions->save();
4292            $results->save();
4293            $self->update_model_stats();
4294            $self->PrintModelLPFile();
4295            $self->run_default_model_predictions();
4296            #Returning results
4297            return $results;
4298    }
4299    
4300    =head3 translate_genes
4301    Definition:
4302            FIGMODELmodel->translate_genes();
4303    Description:
4304    =cut
4305    sub translate_genes {
4306            my ($self) = @_;
4307    
4308            #Loading gene translations
4309            if (!defined($self->{_gene_aliases})) {
4310                    #Loading gene aliases from feature table
4311                    my $tbl = $self->figmodel()->GetGenomeFeatureTable($self->genome());
4312                    if (defined($tbl)) {
4313                            for (my $i=0; $i < $tbl->size(); $i++) {
4314                                    my $row = $tbl->get_row($i);
4315                                    if ($row->{ID}->[0] =~ m/(peg\.\d+)/) {
4316                                            my $geneID = $1;
4317                                            for (my $j=0; $j < @{$row->{ALIASES}}; $j++) {
4318                                                    $self->{_gene_aliases}->{$row->{ALIASES}->[$j]} = $geneID;
4319                                            }
4320                                    }
4321                            }
4322                    }
4323                    #Loading additional gene aliases from the database
4324                    if (-e $self->figmodel()->config("Translation directory")->[0]."AdditionalAliases/".$self->genome().".txt") {
4325                            my $AdditionalAliases = $self->figmodel()->database()->load_multiple_column_file($self->figmodel()->config("Translation directory")->[0]."AdditionalAliases/".$self->genome().".txt","\t");
4326                            for (my $i=0; $i < @{$AdditionalAliases}; $i++) {
4327                                    $self->{_gene_aliases}->{$AdditionalAliases->[$i]->[1]} = $AdditionalAliases->[$i]->[0];
4328                            }
4329                    }
4330            }
4331    
4332            #Cycling through reactions and translating genes
4333            for (my $i=0; $i < $self->reaction_table()->size(); $i++) {
4334                    my $row = $self->reaction_table()->get_row($i);
4335                    if (defined($row->{"ASSOCIATED PEG"})) {
4336                            for (my $j=0; $j < @{$row->{"ASSOCIATED PEG"}}; $j++) {
4337                                    my $Original = $row->{"ASSOCIATED PEG"}->[$j];
4338                                    $Original =~ s/\sand\s/:/g;
4339                                    $Original =~ s/\sor\s/;/g;
4340                                    my @GeneNames = split(/[,\+\s\(\):;]/,$Original);
4341                                    foreach my $Gene (@GeneNames) {
4342                                            if (length($Gene) > 0 && defined($self->{_gene_aliases}->{$Gene})) {
4343                                                    my $Replace = $self->{_gene_aliases}->{$Gene};
4344                                                    $Original =~ s/([^\w])$Gene([^\w])/$1$Replace$2/g;
4345                                                    $Original =~ s/^$Gene([^\w])/$Replace$1/g;
4346                                                    $Original =~ s/([^\w])$Gene$/$1$Replace/g;
4347                                                    $Original =~ s/^$Gene$/$Replace/g;
4348                                            }
4349                                    }
4350                                    $Original =~ s/:/ and /g;
4351                                    $Original =~ s/;/ or /g;
4352                                    $row->{"ASSOCIATED PEG"}->[$j] = $Original;
4353                            }
4354                    }
4355            }
4356    
4357            #Archiving model and saving reaction table
4358            $self->ArchiveModel();
4359            $self->reaction_table()->save();
4360    }
4361    
4362    =head3 feature_web_data
4363    Definition:
4364            string:web output for feature/model connection = FIGMODELmodel->feature_web_data(FIGMODELfeature:feature);
4365    Description:
4366    =cut
4367    sub feature_web_data {
4368            my ($self,$feature) = @_;
4369    
4370            #First checking if the feature is in the model
4371            my $data = $self->get_feature_data($feature->{ID}->[0]);
4372            if (!defined($data)) {
4373                    return "Not in model";
4374            }
4375    
4376            my $output;
4377            #Printing predictions
4378            if (defined($data->{$self->id()."PREDICTIONS"})) {
4379                    #Parsing essentiality data
4380                    my $essentialityData;
4381                    if (defined($feature->{ESSENTIALITY})) {
4382                            for (my $i=0; $i < @{$feature->{ESSENTIALITY}};$i++) {
4383                                    my @temp = split(/:/,$feature->{ESSENTIALITY}->[$i]);
4384                                    $essentialityData->{$temp[0]} = $temp[1];
4385                            }
4386                    }
4387                    my $predictionHash;
4388                    for (my $i=0; $i < @{$data->{$self->id()."PREDICTIONS"}};$i++) {
4389                            my @temp = split(/:/,$data->{$self->id()."PREDICTIONS"}->[$i]);
4390                            if (defined($essentialityData->{$temp[0]})) {
4391                                    if ($temp[1] eq "essential" && $essentialityData->{$temp[0]} eq "essential") {
4392                                            push(@{$predictionHash->{"Correct negative"}},$temp[0]);
4393                                    } elsif ($temp[1] eq "nonessential" && $essentialityData->{$temp[0]} eq "essential") {
4394                                            push(@{$predictionHash->{"False positive"}},$temp[0]);
4395                                    } elsif ($temp[1] eq "essential" && $essentialityData->{$temp[0]} eq "nonessential") {
4396                                            push(@{$predictionHash->{"False negative"}},$temp[0]);
4397                                    } elsif ($temp[1] eq "nonessential" && $essentialityData->{$temp[0]} eq "nonessential") {
4398                                            push(@{$predictionHash->{"Correct positive"}},$temp[0]);
4399                                    }
4400                            } else {
4401                                    push(@{$predictionHash->{$temp[1]}},$temp[0]);
4402                            }
4403                    }
4404                    foreach my $key (keys(%{$predictionHash})) {
4405                            my $string = $key;
4406                            $string = ucfirst($string);
4407                            push(@{$output},'<span title="'.join(", ",@{$predictionHash->{$key}}).'">'.$string.'</span>');
4408                    }
4409            }
4410    
4411            #Printing reactions
4412            if (defined($data->{$self->id()."REACTIONS"})) {
4413                    for (my $i=0; $i < @{$data->{$self->id()."REACTIONS"}};$i++) {
4414                            my $rxnData = $self->get_reaction_data($data->{$self->id()."REACTIONS"}->[$i]);
4415                            my $reactionString = $self->figmodel()->web()->create_reaction_link($data->{$self->id()."REACTIONS"}->[$i],join(" or ",@{$rxnData->{"ASSOCIATED PEG"}}),$self->id());
4416                            if (defined($rxnData->{PREDICTIONS})) {
4417                                    my $predictionHash;
4418                                    for (my $i=0; $i < @{$rxnData->{PREDICTIONS}};$i++) {
4419                                            my @temp = split(/:/,$rxnData->{PREDICTIONS}->[$i]);
4420                                            push(@{$predictionHash->{$temp[1]}},$temp[0]);
4421                                    }
4422                                    $reactionString .= "(";
4423                                    foreach my $key (keys(%{$predictionHash})) {
4424                                            if ($key eq "Essential =>") {
4425                                                    $reactionString .= '<span title="Essential in '.join(",",@{$predictionHash->{$key}}).'">E=></span>,';
4426                                            } elsif ($key eq "Essential <=") {
4427                                                    $reactionString .= '<span title="Essential in '.join(",",@{$predictionHash->{$key}}).'">E<=</span>,';
4428                                            } elsif ($key eq "Active =>") {
4429                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A=></span>,';
4430                                            } elsif ($key eq "Active <=") {
4431                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A<=</span>,';
4432                                            } elsif ($key eq "Active <=>") {
4433                                                    $reactionString .= '<span title="Active in '.join(",",@{$predictionHash->{$key}}).'">A</span>,';
4434                                            } elsif ($key eq "Inactive") {
4435                                                    $reactionString .= '<span title="Inactive in '.join(",",@{$predictionHash->{$key}}).'">I</span>,';
4436                                            } elsif ($key eq "Dead") {
4437                                                    $reactionString .= '<span title="Dead">D</span>,';
4438                                            }
4439                                    }
4440                                    $reactionString =~ s/,$/)/;
4441                            }
4442                            push(@{$output},$reactionString);
4443                    }
4444            }
4445    
4446            #Returning output
4447            return join("<br>",@{$output});
4448    }
4449    
4450  1;  1;

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

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3