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

Diff of /Sprout/ModelSaplingLoader.pm

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

revision 1.3, Thu May 28 18:08:56 2009 UTC revision 1.20, Thu Oct 6 19:05:55 2011 UTC
# Line 16  Line 16 
16  # Genomes at veronika@thefig.info or download a copy from  # Genomes at veronika@thefig.info or download a copy from
17  # http://www.theseed.org/LICENSE.TXT.  # http://www.theseed.org/LICENSE.TXT.
18  #  #
19  use FIGMODEL;  #use FIGMODEL;
20    
21  package ModelSaplingLoader;  package ModelSaplingLoader;
22      use strict;      use strict;
23      use Tracer;      use Tracer;
24      use ERDB;      use ERDB;
     use HTTP::Date;  
25      use base 'BaseSaplingLoader';      use base 'BaseSaplingLoader';
26    
27  =head1 Sapling ModelLoader Load Group Class  =head1 Sapling Model Load Group Class
28    
29  =head2 Introduction  =head2 Introduction
30    
31  The ModelLoader Load Group includes all of the major mdl tables.  The Model Load Group includes a small set of tables that describe reactions and compounds
32    and how they relate to the models in the main model database.
33    
34  =head3 new  =head3 new
35    
36      my $sl = ModelLoaderSaplingLoader->new($erdb, $options, @tables);      my $sl = ModelSaplingLoader->new($erdb, $options);
37    
38  Construct a new ModelLoaderSaplingLoader object.  Construct a new ModelSaplingLoader object.
39    
40  =over 4  =over 4
41    
42  =item erdb  =item erdb
43    
44  [[SaplingPm]] object for the database being loaded.  L<Sapling> object for the database being loaded.
45    
46  =item options  =item options
47    
48  Reference to a hash of command-line options.  Reference to a hash of command-line options.
49    
 =item tables  
   
 List of tables in this load group.  
   
50  =back  =back
51    
52  =cut  =cut
# Line 59  Line 55 
55      # Get the parameters.      # Get the parameters.
56      my ($class, $erdb, $options) = @_;      my ($class, $erdb, $options) = @_;
57      # Create the table list.      # Create the table list.
58      my @tables = sort qw(StructuralCue IsFoundIn Compound HasAliasOf AliasType HasReactionAliasOf Reaction Involves IsTriggeredBy RoleSet IsCombinationOf IsCategorizedInto EcNumber IsConsistentWith IsStimulatedBy  FeatureSet IsSetOf IsRequiredBy Model Encompasses IsModeledBy);      my @tables = qw(Compound Reaction EcNumber Model Media IsTriggeredBy
59                        IsCategorizedInto IsConsistentWith IsModeledBy Involves
60                        IsRequiredBy Complex IsSetOf IsExemplarOf);
61      # Create the BaseSaplingLoader object.      # Create the BaseSaplingLoader object.
62      my $retVal = BaseSaplingLoader::new($class, $erdb, $options, @tables);      my $retVal = BaseSaplingLoader::new($class, $erdb, $options, @tables);
63        # Create the reaction tracking hash.
64        $retVal->{reactions} = {};
65      # Return it.      # Return it.
66      return $retVal;      return $retVal;
67  }  }
# Line 72  Line 72 
72    
73      $sl->Generate();      $sl->Generate();
74    
75  Generate the data for the mdl files.  Generate the data for the model files.
76    
77  =cut  =cut
78    
# Line 81  Line 81 
81      my ($self) = @_;      my ($self) = @_;
82      # Get the database object.      # Get the database object.
83      my $erdb = $self->db();      my $erdb = $self->db();
     # Get the source object.  
     my $fig = $self->source();  
84      # Is this the global section?      # Is this the global section?
     my $model = new FIGMODEL;  
85      if ($self->global()) {      if ($self->global()) {
86          #Loading the model entities and relationships          # Load the tables from the model dump files.
87          $self->LoadModels($model);          $self->LoadModelFiles();
         #Loading structural cues first  
         $self->LoadStructuralCues($model);  
         #Loading the compound entities and relationships  
         $self->LoadCompounds($model);  
         #Loading the reaction, and EC number entities and relationships  
         $self->LoadReactions($model);  
         #Loading the role set entity and relationships  
         $self->LoadRoleSets($model);  
88      } else {      } else {
89          # Get the section ID.          # Get the section ID.
90          my $genomeID = $self->section();          my $genomeID = $self->section();
# Line 103  Line 92 
92      }      }
93  }  }
94    
95  #This function loads all of the StructuralCue entities  =head3 LoadModelFiles
 sub LoadStructuralCues {  
     my ($self,$model) = @_;  
96    
97      #Getting the list of structural cue filenames      $sl->LoadModelFiles();
     my @CuesList = glob($model->{"Reaction database directory"}->[0]."cues/");  
     my %CuePriorities;  
     #TODO:NEED TO POPULATE THE PRIORITIES HASH  
     foreach my $CueFile (@CuesList) {  
         my $Object = FIGMODELObject->load($CueFile,"\t");  
         if (defined($Object) && defined($Object->{"NAME"}->[0])) {  
             my @LoadingArray = ($Object->{"NAME"}->[0],-1,0,0,"","","","");  
             if (defined($CuePriorities{$Object->{"NAME"}->[0]})) {  
                 $LoadingArray[1] = $CuePriorities{$Object->{"NAME"}->[0]};  
             }  
             if (defined($Object->{"SMALL_MOLECULE"}->[0])) {  
                 $LoadingArray[2] = $Object->{"SMALL_MOLECULE"}->[0];  
             }  
             if (defined($Object->{"CHARGE"}->[0])) {  
                 $LoadingArray[3] = $Object->{"CHARGE"}->[0];  
             }  
             if (defined($Object->{"FORMULA"}->[0])) {  
                 $LoadingArray[4] = $Object->{"FORMULA"}->[0];  
             }  
             if (defined($Object->{"ENERGY"}->[0])) {  
                 $LoadingArray[5] = $Object->{"ENERGY"}->[0];  
             }  
             if (defined($Object->{"ERROR"}->[0])) {  
                 $LoadingArray[6] = $Object->{"ERROR"}->[0];  
             }  
             if (defined($Object->{"STRUCTURAL_CUES"}->[0])) {  
                 $LoadingArray[7] = join(";",@{$Object->{"STRUCTURAL_CUES"}});  
             }  
             $self->PutE(StructuralCue => $LoadingArray[0], priority => $LoadingArray[1], smallMolecule => $LoadingArray[2], charge => $LoadingArray[3], formula => $LoadingArray[4],deltaG => $LoadingArray[5], deltaGerr => $LoadingArray[6], subgroups => $LoadingArray[7]);  
         }  
     }  
 }  
98    
99  sub LoadCompounds {  Load the data from the six model dump files.
     my ($self,$model) = @_;  
100    
101      #First getting the compound table which has a list of all compounds in the database as well as alot of compound information  =cut
     my $CompoundTable = $model->GetDBTable("COMPOUNDS");  
102    
103      #Adding the universal AliasType that will always exist  # hash of ubiquitous compounds.
104      $self->PutE(AliasType => "NAME", source => "NONE");  use constant UBIQUITOUS => {
105      $self->PutE(AliasType => "SEARCHNAME", source => "NONE");      cpd00001 => 'OH-',
106      $self->PutE(AliasType => "KEGG", source => "http://www.kegg.com/");      cpd00002 => 'ATP',
107      $self->PutE(AliasType => "ARGONNE", source => "OBSOLETE IDs");      cpd00003 => 'Nicotinamideadeninedinucleotide',
108        cpd00004 => 'Nicotinamideadeninedinucleotide-reduced',
109        cpd00005 => 'Nicotinamideadeninedinucleotidephosphate-reduced',
110        cpd00006 => 'Nicotinamideadeninedinucleotidephosphate',
111        cpd00007 => 'Oxygen',
112        cpd00008 => 'ADP',
113        cpd00009 => 'Orthophosphoric acid',
114        cpd00010 => 'CoenzymeA',
115        cpd00011 => 'Carbon dioxide',
116        cpd00012 => 'PPi',
117        cpd00018 => 'AMP',
118        cpd00020 => 'Pyruvic Acid',
119        cpd00022 => 'Acetyl-CoA',
120        cpd00025 => 'Hydrogen peroxide',
121        cpd00067 => 'H+',
122        cpd00971 => 'Sodium',
123        cpd15352 => '2-Demethylmenaquinone',
124        cpd15353 => '2-Demethylmenaquinol',
125        cpd15499 => 'Menaquinol',
126        cpd15500 => 'Menaquinone',
127        cpd15560 => 'Ubiquinone-8',
128        cpd15561 => 'Ubiquinol-8',
129    };
130    
131      #Cycling through the compound list and adding each individual compound entity  sub LoadModelFiles {
132      for (my $i=0; $i < $CompoundTable->size(); $i++) {      # Get the parameters.
133          my $Row = $CompoundTable->get_row($i);      my ($self) = @_;
134          if (defined($Row) && defined($Row->{"DATABASE"}->[0]) && $Row->{"DATABASE"}->[0] =~ m/cpd\d\d\d\d\d/) {      # Get the sapling database.
135              my $Object = FIGMODELObject->load($model->{"compound directory"}->[0].$Row->{"DATABASE"}->[0],"\t");      my $erdb = $self->db();
136              my @LoadingArray = ($Row->{"DATABASE"}->[0],$Row->{"DATABASE"}->[0],0,"",0,"",0,10000000,10000000,"");      # Get the model dump file directory.
137              $self->Track(compoundRow => $LoadingArray[0], 1000);      my $dir = $erdb->LoadDirectory() . "/models";
138              if (defined($Row->{"NAME"}->[0])) {      # First we read the compounds.
139                  $LoadingArray[1] = $Row->{"NAME"}->[0];      my $ih = $self->CheckFile("$dir/CompoundName.txt", qw(CompoundID Name));
140              }      while (! eof $ih) {
141              if (defined($Object->{"MASS"}->[0])) {          # Get the next compound.
142                  $LoadingArray[2] = $Object->{"MASS"}->[0];          my ($id, $label) = $self->ReadLine($ih);
143              }          # Create a compound record for it.
144              if (defined($Object->{"FORMULA"}->[0])) {          $self->PutE(Compound => $id, label => $label, ubiquitous => (UBIQUITOUS->{$id} ? 1 : 0));
145                  $LoadingArray[3] = $Object->{"FORMULA"}->[0];      }
146              }      # Next, the compound-reactions relationship. We create the reactions here, too.
147              if (defined($Object->{"CHARGE"}->[0])) {      $ih = $self->CheckFile("$dir/CompoundReaction.txt", qw(CompoundID ReactionID
148                  $LoadingArray[4] = $Object->{"CHARGE"}->[0];                             Stoichiometry Cofactor));
149              }      while (! eof $ih) {
150              if (defined($Object->{"CHARGE"}->[0]) && defined($Object->{"FORMULA"}->[0])) {          # Get the next link.
151                  $LoadingArray[5] = FIGMODEL::ConvertToNeutralFormula($Object->{"FORMULA"}->[0],$Object->{"CHARGE"}->[0]);          my ($compound, $reaction, $stoich, $cofactor) = $self->ReadLine($ih);
152              }          # Insure the reaction exists.
153              if (-e $model->{"Argonne molfile directory"}->[0].$Row->{"DATABASE"}->[0].".mol" || -e $model->{"Argonne molfile directory"}->[0]."pH7/".$Row->{"DATABASE"}->[0].".mol") {          $self->CreateReaction($reaction);
154                  $LoadingArray[6] = 1;          # Check for product or substrate.
155              }          my $product;
156              if (defined($Object->{"DELTAG"}->[0])) {          if ($stoich < 0) {
157                  $LoadingArray[7] = $Object->{"DELTAG"}->[0];              $product = 0;
158              }              $stoich = -$stoich;
159              if (defined($Object->{"DELTAGERR"}->[0])) {          } else {
160                  $LoadingArray[8] = $Object->{"DELTAGERR"}->[0];              $product = 1;
             }  
             if (defined($Row->{"STRINGCODE"}->[0])) {  
                 $LoadingArray[9] = $Row->{"STRINGCODE"}->[0];  
             }  
             $self->PutE(Compound => $LoadingArray[0], label => $LoadingArray[1], mass => $LoadingArray[2], chargedFormula => $LoadingArray[3], charge => $LoadingArray[4],neutralFormula => $LoadingArray[5], hasMolfile => $LoadingArray[6], deltaG => $LoadingArray[7], deltaGerr => $LoadingArray[8], stringcode => $LoadingArray[9]);  
             #Adding the relationship between compound and structural cue  
             if (defined($Object->{"STRUCTURAL_CUES"})) {  
                 foreach my $Cue (@{$Object->{"STRUCTURAL_CUES"}}) {  
                     my @TempArray = split(/:/,$Cue);  
                     if (@TempArray == 2) {  
                         $self->PutR(IsFoundIn => $TempArray[0],$LoadingArray[0],count => $TempArray[1]);  
                     }  
                 }  
             }  
             #Adding the relationship between compound and alias type  
             if (defined($Object->{"NAME"})) {  
                 foreach my $Name (@{$Object->{"NAME"}}) {  
                     $self->PutR(HasAliasOf => $LoadingArray[0],"NAME",alias => $Name);  
                     my @SearchNames = FIGMODEL::ConvertToSearchNames($Name);  
                     foreach my $SearchName (@SearchNames) {  
                         $self->PutR(HasAliasOf => $LoadingArray[0],"SEARCHNAME",alias => $SearchName);  
                     }  
                 }  
             }  
             if (defined($Object->{"DBLINKS"})) {  
                 foreach my $Link (@{$Object->{"DBLINKS"}}) {  
                     my @TempArray = split(/:/,$Link);  
                     if (@TempArray >= 2) {  
                         if ($TempArray[0] ne "KEGG" && $TempArray[0] ne "ARGONNE") {  
                             $self->PutE(AliasType => $TempArray[0], source => "PUBLISHED MODEL");  
                         }  
                         if ($TempArray[0] eq "ARGONNE") {  
                             splice(@TempArray,1,1);  
                         }  
                         for (my $j=1; $j < @TempArray; $j++) {  
                             $self->PutR(HasAliasOf => $LoadingArray[0],$TempArray[0],alias => $TempArray[$j]);  
                         }  
                     }  
                 }  
             }  
         }  
     }  
161  }  }
162            # Connect the reaction to the compound.
163            $self->PutR(Involves => $reaction, $compound, product => $product,
164                        stoichiometry => $stoich, cofactor => $cofactor);
165        }
166        # Before we go on, we need to get a map of the modelSEED role IDs to
167        # the SEED role IDs. This is found in the Role.txt file, along with the
168        # exemplar data.
169        my %roleHash;
170        $ih = $self->CheckFile("$dir/Role.txt", qw(RoleID Name ExemplarID));
171        while (! eof $ih) {
172            # Get the next role's record.
173            my ($roleID, $role, $exemplarList) = $self->ReadLine($ih);
174            # Map the role ID to the role name (which is the SEED's ID).
175            $roleHash{$roleID} = $role;
176            # If there is are exemplars, store them.
177            if ($exemplarList && $exemplarList ne 'NONE') {
178                for my $exemplar (split /\s*,\s*/, $exemplarList) {
179                    $self->PutR(IsExemplarOf => $exemplar, $role);
180                }
181            }
182        }
183        # The next step is to create the complexes. We load into memory a
184        # hash mapping the complexes to their reactions. This is later
185        # used to insure we have reaction-to-role coverage.
186        my %cpxHash;
187        $ih = $self->CheckFile("$dir/ReactionComplex.txt", qw(ReactionID ComplexID));
188        while (! eof $ih) {
189            # Get the next reaction/complex pair.
190            my ($rxn, $cpx) = $self->ReadLine($ih);
191            # Is this a new complex?
192            if (! exists $cpxHash{$cpx}) {
193                # Yes. Create a record for it.
194                $self->PutE(Complex => $cpx);
195                $cpxHash{$cpx} = [];
196            }
197            # Insure the reaction exists.
198            $self->CreateReaction($rxn);
199            # Connect the complex to the reaction.
200            $self->PutR(IsSetOf => $cpx, $rxn);
201            push @{$cpxHash{$cpx}}, $rxn;
202        }
203        # Here we connect the complexes to the roles. Along the way, we
204        # create a hash listing of all of a reaction's roles. That hash
205        # will be used to check for missing reaction/role links later on.
206        my %rxnHash;
207        $ih = $self->CheckFile("$dir/ComplexRole.txt", qw(RoleID ComplexID));
208        while (! eof $ih) {
209            # Get the next role/complex pair.
210            my ($roleID, $cpx) = $self->ReadLine($ih);
211            # Connect the role to the complex.
212            $self->PutR(IsTriggeredBy => $cpx, $roleHash{$roleID}, optional => 0);
213            # Denote that this role is connected to the complex's reactions.
214            for my $rxn (@{$cpxHash{$cpx}}) {
215                push @{$rxnHash{$rxn}}, $roleID;
216            }
217        }
218        # We don't need the complex hash any more. Instead, we're going to
219        # use it to track single-reaction complexes we create.
220        %cpxHash = ();
221        # Now we fill in the missing reaction-to-role connections.
222        $ih = $self->CheckFile("$dir/ReactionRole.txt", qw(ReactionID Role));
223        while (! eof $ih) {
224            # Get the next reaction/role pair.
225            my ($reaction, $role) = $self->ReadLine($ih);
226            # Insure the reaction exists.
227            $self->CreateReaction($reaction);
228            # Is this reaction already connected to this role?
229            my $roleList = $rxnHash{$reaction};
230            if (! $roleList || ! (grep { $roleHash{$_} eq $role } @{$rxnHash{$reaction}})) {
231                # No, so we have to do it the hard way.
232                if (! exists $cpxHash{$reaction}) {
233                    # Here the reaction has not had a complex created, so we
234                    # must create one.
235                    $self->Add(pseudoComplex => 1);
236                    $self->PutE(Complex => $reaction);
237                    $self->PutR(IsSetOf => $reaction, $reaction);
238                }
239                # Connect the reaction's complex to this role.
240                $self->PutR(IsTriggeredBy => $reaction, $role);
241                $self->Add(missingTrigger => 1);
242            }
243        }
244        # Now we create the models.
245        $ih = $self->CheckFile("$dir/ModelGenome.txt", qw(ModelID Name GenomeID));
246        while (! eof $ih) {
247            # Get the next model.
248            my ($model, $name, $genome) = $self->ReadLine($ih);
249            # Create the model.
250            $self->PutE(Model => $model);
251            # Connect it to the genome. Again, the genomes are created elsewhere.
252            $self->PutR(IsModeledBy => $genome, $model);
253        }
254        # Next we connect the reactions to models.
255        $ih = $self->CheckFile("$dir/ModelReaction.txt", qw(ModelID ReactionID));
256        while (! eof $ih) {
257            # Get the next line.
258            my ($model, $reaction) = $self->ReadLine($ih);
259            # Only proceed if a reaction is present.
260            if ($reaction) {
261                # Insure the reaction exists.
262                $self->CreateReaction($reaction);
263                # Connect the reaction to the model.
264                $self->PutR(IsRequiredBy => $reaction, $model);
265            }
266        }
267    }
268    
269    =head3 CheckFile
270    
271        my $ih = $sl->CheckFile($fileName, @fieldNames);
272    
273    Read the header record of the specified file and verify that the field names match
274    the names in the input list. If they do not, an error will be thrown; if they do, an
275    open file handle will be returned, positioned on the first data record.
276    
277  sub LoadReactions {  =over 4
     my ($self,$model) = @_;  
     #First getting the reaction table which has a list of all reactions in the database as well as alot of reaction information  
     my $ReactionTable = $model->GetDBTable("REACTIONS");  
278    
279      #Cycling through the compound list and adding each individual compound entity  =item fileName
280      my $Count = 0;  
281      for (my $i=0; $i < $ReactionTable->size(); $i++) {  Name for the input file. The file is in standard tab-delimited format. The first record
282          my $Row = $ReactionTable->get_row($i);  contains the field names and the remaining records contain the data.
283          if (defined($Row) && defined($Row->{"DATABASE"}->[0]) && $Row->{"DATABASE"}->[0] =~ m/rxn\d\d\d\d\d/) {  
284              my $Object = FIGMODELObject->load($model->{"reaction directory"}->[0].$Row->{"DATABASE"}->[0],"\t");  =item fieldNames
285              my @LoadingArray = ($Row->{"DATABASE"}->[0],"","","","","",10000000,10000000,10000000,"R");  
286              $self->Track(reactionRow => $LoadingArray[0], 1000);  List of the field names expected, in order.
287              if (defined($Object->{"DEFINITION"}->[0])) {  
288                  $LoadingArray[1] = $Object->{"DEFINITION"}->[0];  =item RETURN
289              }  
290              if (defined($Object->{"EQUATION"}->[0])) {  Returns the open file handle if successful. If there is a mismatch, throws an error.
291                  my ($Direction,$Equation,$ReverseEquation,$FullEquation,$EquationCompartment,$Error) = $model->ConvertEquationToCode($Object->{"EQUATION"}->[0],{"Test" => "Test"});  
292                  $LoadingArray[2] = $Equation;  =back
293              }  
294              if (defined($Object->{"OPERATOR"}->[0])) {  =cut
295                  $LoadingArray[3] = $Object->{"OPERATOR"}->[0];  
296              }  sub CheckFile {
297              if (defined($Object->{"PATHWAY"}->[0])) {      # Get the parameters.
298                  $LoadingArray[4] = join(";",@{$Object->{"PATHWAY"}});      my ($self, $fileName, @fieldNames) = @_;
299              }      # Open the file.
300              if (defined($Row->{"KEGG MAPS"}->[0])) {      my $retVal = Open(undef, "<$fileName");
301                  $LoadingArray[5] = join(";",@{$Row->{"KEGG MAPS"}});      $self->Add(files => 1);
302              }      # Read in the file header.
303              if (defined($Object->{"DELTAG"}->[0])) {      my @actualFields = Tracer::GetLine($retVal);
304                  $LoadingArray[6] = $Object->{"DELTAG"}->[0];      # This will be set to TRUE if there's a mismatch.
305              }      my $error = 0;
306              if (defined($Object->{"MMDELTAG"}->[0])) {      for (my $i = 0; $i <= $#fieldNames; $i++) {
307                  $LoadingArray[7] = $Object->{"MMDELTAG"}->[0];          if ($fieldNames[$i] ne $actualFields[$i]) {
308              }              Trace("Field match error: expected $fieldNames[$i], found $actualFields[$i].") if T(0);
309              if (defined($Object->{"DELTAGERR"}->[0])) {              $error = 1;
310                  $LoadingArray[8] = $Object->{"DELTAGERR"}->[0];          }
311              }      }
312              if (defined($Object->{"THERMODYNAMIC REVERSIBILITY"}->[0])) {      # Was there an error?
313                  my $code = $Object->{"THERMODYNAMIC REVERSIBILITY"}->[0];      if ($error) {
314                  if ($code eq '<=>') {          # Yes, so abort.
315                      $LoadingArray[9] = "R";          Confess("Invalid field name header in $fileName.");
                 } elsif ($code eq '<=') {  
                     $LoadingArray[9] = "B";  
                 } elsif ($code eq '=>') {  
                     $LoadingArray[9] = "F";  
                 }  
             }  
             $self->PutE(Reaction => $LoadingArray[0], definition => $LoadingArray[1], code => $LoadingArray[2], operator => $LoadingArray[3], pathway => $LoadingArray[4],keggMap => $LoadingArray[5], deltaG => $LoadingArray[6], MMdeltaG => $LoadingArray[7], deltaGerr => $LoadingArray[8], predictedReversibility => $LoadingArray[9]);  
             #Adding relationship between compounds and reactions  
             my ($Reactants,$Products) = $model->GetReactionSubstrateData($LoadingArray[0]);  
             if (! defined $Reactants) {  
                 $self->Add(missingReactants => 1);  
             } else {  
                 for (my $j=0; $j < @{$Reactants}; $j++) {  
                     $self->PutR(Involves => $LoadingArray[0],$Reactants->[$j]->{"DATABASE"}->[0],product => 0,stoichiometry => $Reactants->[$j]->{"COEFFICIENT"}->[0],main => 1,compartment => $Reactants->[$j]->{"COMPARTMENT"}->[0],discriminator => $Count);  
                     #TODO:Properly identify main reactants in reactions  
                     $Count++;  
                 }  
             }  
             if (! defined $Products) {  
                 $self->Add(missingProducts => 1);  
316              } else {              } else {
317                  for (my $j=0; $j < @{$Products}; $j++) {          # No, so trace the open.
318                      $self->PutR(Involves => $LoadingArray[0],$Products->[$j]->{"DATABASE"}->[0],product => 1,stoichiometry => $Products->[$j]->{"COEFFICIENT"}->[0],main => 1,compartment => $Products->[$j]->{"COMPARTMENT"}->[0],discriminator => $Count);          Trace("Processing $fileName.") if T(ERDBLoadGroup => 2);
                     #TODO:Properly identify main reactants in reactions  
                     $Count++;  
                 }  
             }  
             #Adding relationship between EC number and reactions  
             if (defined($Object->{"ENZYME"})) {  
                 foreach my $Enzyme (@{$Object->{"ENZYME"}}) {  
                    $self->PutE(EcNumber => $Enzyme, obselete => 0, replacedby => "NONE");  
                    $self->PutR(IsCategorizedInto => $LoadingArray[0],$Enzyme,source => "KEGG");  
                 }  
             }  
             #Adding the relationship between reaction and alias type  
             if (defined($Object->{"NAME"})) {  
                 foreach my $Name (@{$Object->{"NAME"}}) {  
                     $self->PutR(HasReactionAliasOf => $LoadingArray[0],"NAME",alias => $Name);  
                 }  
             }  
             if (defined($Object->{"DBLINKS"})) {  
                 foreach my $Link (@{$Object->{"DBLINKS"}}) {  
                     my @TempArray = split(/:/,$Link);  
                     if (@TempArray >= 2) {  
                         if ($TempArray[0] ne "KEGG" && $TempArray[0] ne "ARGONNE") {  
                             $self->PutE(AliasType => $TempArray[0], source => "PUBLISHED MODEL");  
                         }  
                         if ($TempArray[0] eq "ARGONNE") {  
                             splice(@TempArray,1,1);  
                         }  
                         for (my $j=1; $j < @TempArray; $j++) {  
                             $self->PutR(HasReactionAliasOf => $LoadingArray[0],$TempArray[0],alias => $TempArray[$j]);  
                         }  
                     }  
                 }  
             }  
         }  
319      }      }
320        # Return the file handle.
321        return $retVal;
322  }  }
323    
324  sub LoadRoleSets {  =head3 ReadLine
     my ($self,$model) = @_;  
     my $sapling =$self->db();  
     my $RoleMappings = $model->GetDBTable("CURATED ROLE MAPPINGS");  
     my $NewSet;  
     my $SetHash;  
     my $LastComplex = -1;  
     my $LastReaction = "";  
     my $LastRole = "";  
     for (my $i=0; $i < $RoleMappings->size(); $i++) {  
         my $Row = $RoleMappings->get_row($i);  
         if (defined($Row) && defined($Row->{"REACTION"}->[0]) && defined($Row->{"ROLE"}->[0]) && defined($Row->{"COMPLEX"}->[0]) && defined($Row->{"MASTER"}->[0])) {  
             if ($Row->{"REACTION"}->[0] ne $LastReaction || $LastComplex ne $Row->{"COMPLEX"}->[0]) {  
                 if (defined($NewSet->{"ROLES"}) && defined($NewSet->{"REACTIONS"})) {  
                     my @RoleList = sort(keys(%{$NewSet->{"ROLES"}}));  
                     my @ReactionList = keys(%{$NewSet->{"REACTIONS"}});  
                     foreach my $Reaction (@ReactionList) {  
                         $SetHash->{join("+",@RoleList)}->{"REACTIONS"}->{$Reaction}->{"MASTER"}->[0] = $NewSet->{"REACTIONS"}->{$Reaction}->{"MASTER"}->[0];  
                         if (defined($NewSet->{"REACTIONS"}->{$Reaction}->{"SUBSYSTEMS"})) {  
                             foreach my $Subsystem (@{$NewSet->{"REACTIONS"}->{$Reaction}->{"SUBSYSTEMS"}}) {  
                                 if (defined($SetHash->{join("+",@RoleList)}->{"REACTIONS"}->{$Reaction}->{"SUBSYSTEMS"})) {  
                                     foreach my $OtherSubsystem (@{$SetHash->{join("+",@RoleList)}->{"REACTIONS"}->{$Reaction}->{"SUBSYSTEMS"}}) {  
                                         if ($Subsystem eq $OtherSubsystem) {  
                                             $Subsystem = "";  
                                             last;  
                                         }  
                                     }  
                                 }  
                                 if ($Subsystem ne "") {  
                                     push(@{$SetHash->{join("+",@RoleList)}->{"REACTIONS"}->{$Reaction}->{"SUBSYSTEMS"}},$Subsystem);  
                                 }  
                             }  
                         }  
                     }  
                     foreach my $Role (@RoleList) {  
                         $SetHash->{join("+",@RoleList)}->{"ROLES"}->{$Role} = 1;  
                     }  
                 }  
                 $NewSet = {};  
             }  
             $NewSet->{"ROLES"}->{$Row->{"ROLE"}->[0]} = 1;  
             $NewSet->{"REACTIONS"}->{$Row->{"REACTION"}->[0]}->{"MASTER"}->[0] = $Row->{"MASTER"}->[0];  
             if (defined($Row->{"SUBSYSTEM"}->[0])) {  
                 push(@{$NewSet->{"REACTIONS"}->{$Row->{"REACTION"}->[0]}->{"SUBSYSTEMS"}},$Row->{"SUBSYSTEM"}->[0]);  
             }  
             $LastRole = $Row->{"ROLE"}->[0];  
             $LastReaction = $Row->{"REACTION"}->[0];  
             $LastComplex = $Row->{"COMPLEX"}->[0];  
         }  
     }  
325    
326      my @RoleSets = keys(%{$SetHash});      my @fields = $sl->ReadLine($ih);
     foreach my $RoleSet (@RoleSets) {  
         my $Digested = $sapling->DigestKey($RoleSet);  
         $self->PutE(RoleSet => $Digested, source => "NONE");  
         my @ReactionList = keys(%{$SetHash->{$RoleSet}->{"REACTIONS"}});  
         foreach my $Reaction (@ReactionList) {  
             $self->PutR(IsTriggeredBy => $Reaction,$Digested, source => "NONE",master => $SetHash->{$RoleSet}->{"REACTIONS"}->{$Reaction}->{"MASTER"}->[0],subsystem => join(";",@{$SetHash->{$RoleSet}->{"REACTIONS"}->{$Reaction}->{"SUBSYSTEMS"}}));  
         }  
         my @RoleList = keys(%{$SetHash->{$RoleSet}->{"ROLES"}});  
         foreach my $Role (@RoleList) {  
             $self->PutR(IsCombinationOf => $Digested,$Role, local => 0);  
         }  
     }  
 }  
327    
328  sub LoadModels {  Read a line of data from an input file.
329      my ($self,$model) = @_;  
330      my $sapling = $self->db();  =over 4
331      ## TRS: Get hash of valid genome IDs.  
332      my $genomeHash = $sapling->GenomeHash();  =item ih
333      my $ModelList = $model->GetDBTable("MODEL LIST");  
334      my $ModelStats = $model->GetDBTable("MODEL STATS");  Open file handle for the input file.
335      for (my $i=0; $i < $ModelStats->size(); $i++) {  
336          my $Row = $ModelStats->get_row($i);  =item RETURN
337          if (defined($Row) && defined($Row->{"Model ID"}->[0])) {  
338              my @LoadingArray = ($Row->{"Model ID"}->[0],"","",0,0,0,"",0,0,0,0,0,0,0,0,0,0,0,0,"","",0,0,"",0,0);  Returns a list of the field values for the next record in the file.
339              if (defined($Row->{"Genome ID"}->[0]) && $genomeHash->{$Row->{"Genome ID"}->[0]}) {  
340                  if (defined($Row->{"Organism name"}->[0])) {  =back
341                      $LoadingArray[1] = $Row->{"Organism name"}->[0];  
342                  }  =cut
343                  if (defined($Row->{"Source"}->[0])) {  
344                      $LoadingArray[2] = $Row->{"Source"}->[0];  sub ReadLine {
345                  }      # Get the parameters.
346                  if (defined($Row->{"Total genes"}->[0])) {      my ($self, $ih) = @_;
347                      $LoadingArray[3] = $Row->{"Total genes"}->[0];      # Read the line.
348                  }      my @retVal = Tracer::GetLine($ih);
349                  if (defined($Row->{"Gram positive genes"}->[0])) {      # Count this record.
350                      $LoadingArray[4] = $Row->{"Gram positive genes"}->[0];      $self->Track(records => $retVal[0], 1000);
351                  }      # Return the data.
352                  if (defined($Row->{"Gram negative genes"}->[0])) {      return @retVal;
                     $LoadingArray[5] = $Row->{"Gram negative genes"}->[0];  
                 }  
                 if (defined($Row->{"Class"}->[0])) {  
                     $LoadingArray[6] = $Row->{"Class"}->[0];  
                 }  
                 if (defined($Row->{"Genes with functions"}->[0])) {  
                     $LoadingArray[7] = $Row->{"Genes with functions"}->[0];  
                 }  
                 if (defined($Row->{"Genes with reactions"}->[0])) {  
                     $LoadingArray[8] = $Row->{"Genes with reactions"}->[0];  
                 }  
                 if (defined($Row->{"Subsystem genes"}->[0])) {  
                     $LoadingArray[9] = $Row->{"Subsystem genes"}->[0];  
                 }  
                 if (defined($Row->{"Subsystem genes with reactions"}->[0])) {  
                     $LoadingArray[10] = $Row->{"Subsystem genes with reactions"}->[0];  
                 }  
                 if (defined($Row->{"Nonsubsystem genes"}->[0])) {  
                     $LoadingArray[11] = $Row->{"Nonsubsystem genes"}->[0];  
                 }  
                 if (defined($Row->{"Nonsubsystem genes with reactions"}->[0])) {  
                     $LoadingArray[12] = $Row->{"Nonsubsystem genes with reactions"}->[0];  
                 }  
                 if (defined($Row->{"Number of reactions"}->[0])) {  
                     $LoadingArray[13] = $Row->{"Number of reactions"}->[0];  
                 }  
                 if (defined($Row->{"Transport reaction"}->[0])) {  
                     $LoadingArray[14] = $Row->{"Transport reaction"}->[0];  
                 }  
                 if (defined($Row->{"Gap filling reactions"}->[0])) {  
                     $LoadingArray[15] = $Row->{"Gap filling reactions"}->[0];  
                 }  
                 if (defined($Row->{"Gap filling time"}->[0])) {  
                     $LoadingArray[16] = $Row->{"Gap filling time"}->[0];  
                 }  
                 if (defined($Row->{"Gap filling objective"}->[0])) {  
                     $LoadingArray[17] = $Row->{"Gap filling objective"}->[0];  
                 }  
                 if (defined($Row->{"Gap filling minimal objective"}->[0])) {  
                     $LoadingArray[18] = $Row->{"Gap filling minimal objective"}->[0];  
                 }  
                 if (defined($Row->{"Build date"}->[0])) {  
                     $LoadingArray[19] = $Row->{"Build date"}->[0];  
                 }  
                 if (defined($Row->{"Gap fill date"}->[0])) {  
                     $LoadingArray[20] = $Row->{"Gap fill date"}->[0];  
                 }  
                 if (defined($Row->{"Version"}->[0])) {  
                     $LoadingArray[21] = $Row->{"Version"}->[0];  
                 }  
                 if (defined($Row->{"Gap fill version"}->[0])) {  
                     $LoadingArray[22] = $Row->{"Gap fill version"}->[0];  
                 }  
                 if ($Row->{"Model ID"}->[0] =~ m/Core\d+\.\d+V\d+\.\d+/) {  
                     $LoadingArray[25] = 1;  
                 } elsif (defined($ModelList->get_row_by_key($Row->{"Model ID"}->[0],"MODEL ID"))) {  
                     if (defined($ModelList->get_row_by_key($Row->{"Model ID"}->[0],"MODEL ID")->{"DIRECTORY"}->[0])) {  
                         $LoadingArray[23] = $ModelList->get_row_by_key($Row->{"Model ID"}->[0],"MODEL ID")->{"DIRECTORY"}->[0];  
                     }  
                     if (defined($ModelList->get_row_by_key($Row->{"Model ID"}->[0],"MODEL ID")->{"JOB ID"}->[0]) && $ModelList->get_row_by_key($Row->{"Model ID"}->[0],"MODEL ID")->{"JOB ID"}->[0] ne "NONE") {  
                         $LoadingArray[24] = $ModelList->get_row_by_key($Row->{"Model ID"}->[0],"MODEL ID")->{"JOB ID"}->[0];  
                     }  
                 }  
                 for my $j (3,4,5,7,8,9,10,11,12,13,14,15,16,17,18,21,22,24,25) {  
                     $LoadingArray[$j] = 0 if ($LoadingArray[$j] =~ /[a-z]/i);  
                 }  
                 $self->PutE(Model => $LoadingArray[0], organismName => $LoadingArray[1], source => $LoadingArray[2], totalGenes => $LoadingArray[3], gramPositiveGenes => $LoadingArray[4],gramNegativeGenes => $LoadingArray[5], class => $LoadingArray[6], genesWithFunction => $LoadingArray[7], genesWithReactions => $LoadingArray[8], subsystemGenes => $LoadingArray[9], subsystemGenesWithReactions => $LoadingArray[10], nonsubsystemGenes => $LoadingArray[11], nonsubsystemGenesWithReactions => $LoadingArray[12], numberOfReactions => $LoadingArray[13], numberOfTransporters => $LoadingArray[14], gapFillingReactions => $LoadingArray[15], gapFillingTime => $LoadingArray[16], gapFillingObjective => $LoadingArray[17], gapFillingMinimalObjective => $LoadingArray[18], buildDate => $LoadingArray[19], gapFillDate => $LoadingArray[20], version => $LoadingArray[21], gapFillVersion => $LoadingArray[22], directory => $LoadingArray[23], jobid => $LoadingArray[24], obsolete => $LoadingArray[25]);  
                 #Adding the relationship between model and genome  
                 if (defined($Row->{"Genome ID"}->[0])) {  
                     $self->PutR(IsModeledBy => $Row->{"Genome ID"}->[0],$LoadingArray[0]);  
                 }  
                 #If the model is not obsolete, we add the relationships between model and reaction and featureset  
                 if ($LoadingArray[25] == 0) {  
                     #Loading the model from file  
                     my $ModelTable = $model->GetDBModel($LoadingArray[0]);  
                     for (my $j=0; $j < $ModelTable->size(); $j++) {  
                         my $RxnRow = $ModelTable->get_row($j);  
                         if (defined($RxnRow) && defined($RxnRow->{"LOAD"}->[0])) {  
                             my @SubLoadingArray = ("R","c","NONE",10,"V","NONE","UNKNOWN");  
                             if (defined($RxnRow->{"DIRECTIONALITY"}->[0])) {  
                                 my $code = $RxnRow->{"DIRECTIONALITY"}->[0];  
                                 if ($code eq '<=>') {  
                                     $SubLoadingArray[0] = 'R';  
                                 } elsif ($code eq '<=') {  
                                     $SubLoadingArray[0] = 'B';  
                                 } elsif ($code eq '=>') {  
                                     $SubLoadingArray[0] = 'F';  
                                 }  
                             }  
                             if (defined($RxnRow->{"COMPARTMENT"}->[0])) {  
                                 $SubLoadingArray[1] = $RxnRow->{"COMPARTMENT"}->[0];  
                             }  
                             if (defined($RxnRow->{"SUBSYSTEM"})) {  
                                 $SubLoadingArray[2] = join(";",@{$RxnRow->{"SUBSYSTEM"}});  
                             }  
                             if (defined($RxnRow->{"CONFIDENCE"}->[0])) {  
                                 $SubLoadingArray[3] = $RxnRow->{"CONFIDENCE"}->[0];  
                                 if ($SubLoadingArray[3] eq 'NONE') {  
                                     $SubLoadingArray[3] = 10;  
                                 }  
                             }  
                             if (defined($RxnRow->{"NOTES"})) {  
                                 $SubLoadingArray[5] = join(";",@{$RxnRow->{"NOTES"}});  
                             }  
                             if (defined($RxnRow->{"ASSOCIATED PEG"})) {  
                                 #Adding the role set entities  
                                 foreach my $FeatureSet (@{$RxnRow->{"ASSOCIATED PEG"}}) {  
                                     if ($FeatureSet =~ m/peg\.\d+/) {  
                                         my $DigestedKey = $sapling->DigestKey($FeatureSet);  
                                         $self->PutE(FeatureSet => $DigestedKey, source => "NONE");  
                                         #Adding the relationship between the reaction and roleset  
                                         $self->PutR(IsStimulatedBy => $RxnRow->{"LOAD"}->[0],$DigestedKey);  
                                         #Adding the relationship between the model and featureset  
                                         $self->PutR(Encompasses => $LoadingArray[0],$DigestedKey);  
                                         #Adding the relationship between FeatureSet and feature  
                                         my @PegArray = split(/\+/,$FeatureSet);  
                                         foreach my $Feature (@PegArray) {  
                                             if ($Feature =~ m/(peg\.\d+)/) {  
                                                 $self->PutR(IsSetOf => $DigestedKey,"fig|".$Row->{"Genome ID"}->[0].".".$1);  
                                             }  
                                         }  
                                     }  
                                 }  
                                 $SubLoadingArray[6] = join(";",@{$RxnRow->{"ASSOCIATED PEG"}});  
                             }  
                             $self->PutR(IsRequiredBy => $RxnRow->{"LOAD"}->[0],$LoadingArray[0], direction => $SubLoadingArray[0], compartment => $SubLoadingArray[1], confidence => $SubLoadingArray[3], class => $SubLoadingArray[4], notes => $SubLoadingArray[5], dependency => $SubLoadingArray[6]);  
                         }  
                     }  
                     #Clearing the model data from memmory  
                     undef $ModelTable;  
                     $model->ClearDBModel($LoadingArray[0],"DELETE");  
                 }  
             }  
353          }          }
354    
355    
356    =head3 CheckReaction
357    
358        $sl->CheckReaction($reaction);
359    
360    Insure we have created a rectord for the specified reaction.
361    
362    =over 4
363    
364    =item reaction
365    
366    ID of the reaction in question.
367    
368    =back
369    
370    =cut
371    
372    sub CreateReaction {
373        # Get the parameters.
374        my ($self, $reaction) = @_;
375        # Get the reaction hash.
376        my $reactionH = $self->{reactions};
377        # See if this reaction is new.
378        if (! $reactionH->{$reaction}) {
379            # It is, so create it.
380            $self->PutE(Reaction => $reaction);
381            # Insure we don't create it again.
382            $reactionH->{$reaction} = 1;
383      }      }
384  }  }
385    

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.20

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3