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

Annotation of /FigKernelPackages/FileIOFunctions.pm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.1 - (view) (download) (as text)

1 : chenry 1.1 use strict;
2 :     use FileHandle;
3 :    
4 :     #--- This function just prints the given array reference to file with a different array element on each line ---#
5 :     sub PrintArrayToFile {
6 :     my ($Filename,$ArrayRef) = @_;
7 :    
8 :     if (open (OUTPUT, ">$Filename")) {
9 :     foreach my $Item (@{$ArrayRef}) {
10 :     if (length($Item) > 0) {
11 :     print OUTPUT $Item."\n";
12 :     }
13 :     }
14 :     close(OUTPUT);
15 :     } else {
16 :     die "Cannot open $Filename: $!";
17 :     }
18 :     }
19 :    
20 :     sub PrintTwoDimensionalArrayToFile {
21 :     my ($Filename,$ArrayRef,$Delimiter) = @_;
22 :    
23 :     if (open (OUTPUT, ">$Filename")) {
24 :     foreach my $Item (@{$ArrayRef}) {
25 :     if (@{$Item} > 0) {
26 :     print OUTPUT join($Delimiter,@{$Item})."\n";
27 :     }
28 :     }
29 :     close(OUTPUT);
30 :     } else {
31 :     die "Cannot open $Filename: $!";
32 :     }
33 :     }
34 :    
35 :    
36 :     #--- This function removes the specified line from the file with the input filename if the line exists in the file ---#
37 :     sub RemoveSpecificLineFromFile {
38 :     my ($Filename,$DelLine,$Delimiter) = @_;
39 :    
40 :     #Note that I donot specify the delimiter to the file upload function because I want to preserve the entire content of the file
41 :     my $FileArray = &LoadSingleColumnFile($Filename,"");
42 :     my $Count = 0;
43 :     foreach my $Item (@{$FileArray}) {
44 :     my @Data = split(/$Delimiter/,$Item);
45 :     if ($Data[0] eq $DelLine) {
46 :     delete $FileArray->[$Count];
47 :     }
48 :     $Count++;
49 :     }
50 :     &PrintArrayToFile($Filename,$FileArray);
51 :     }
52 :    
53 :     #--- This function adds the input line to the file with the input filename if the line does not already exist in the file ---#
54 :     sub AddLineToFileUnique {
55 :     my ($Filename,$NewLine,$Delimiter) = @_;
56 :     my $FileArray = &LoadSingleColumnFile($Filename,$Delimiter);
57 :     foreach my $Item (@{$FileArray}) {
58 :     if ($Item eq $NewLine) {
59 :     return;
60 :     }
61 :     }
62 :     if (open (OUTPUT, ">>$Filename")) {
63 :     print OUTPUT $NewLine."\n";
64 :     close(OUTPUT);
65 :     } else {
66 :     die "Cannot open $Filename: $!";
67 :     }
68 :     }
69 :    
70 :     #--- This function saves the input hash back to a file where each data item is stored on a separate line with the file headings stored in the first column of data ---#
71 :     sub SaveHashToHorizontalDataFile {
72 :     my ($Filename,$Delimiter,$DataHashRef) = @_;
73 :    
74 :     if (!defined($DataHashRef->{"orderedkeys"})) {
75 :     my @Keys = keys(%{$DataHashRef});
76 :     push(@{$DataHashRef->{"orderedkeys"}},@Keys);
77 :     }
78 :    
79 :     if ($Filename eq "") {
80 :     open (HASHTOHORIZONTALOUTPUT, ">&STDOUT");
81 :     } else {
82 :     open (HASHTOHORIZONTALOUTPUT, ">$Filename");
83 :     }
84 :    
85 :     if (open (HASHTOHORIZONTALOUTPUT, ">$Filename")) {
86 :     my @ReactionKeys = @{$DataHashRef->{"orderedkeys"}};
87 :     foreach my $Item (@ReactionKeys) {
88 :     if (defined($DataHashRef->{"keytranslation"}) && defined($DataHashRef->{"keytranslation"}->{$Item})) {
89 :     $Item = $DataHashRef->{"keytranslation"}->{$Item};
90 :     }
91 :     if (defined($DataHashRef->{$Item}) && @{$DataHashRef->{$Item}} > 0) {
92 :     print HASHTOHORIZONTALOUTPUT $Item.$Delimiter.join($Delimiter,@{$DataHashRef->{"$Item"}})."\n";
93 :     }
94 :     }
95 :     close(HASHTOHORIZONTALOUTPUT);
96 :     } else {
97 :     die "Cannot open $Filename: $!";
98 :     }
99 :    
100 :     return $DataHashRef;
101 :     }
102 :    
103 :     #--- This function loads a file where each data item is stored on a separate line with the file headings stored in the first column of data ---#
104 :     sub LoadHorizontalDataFile {
105 :     my ($Filename,$Delimiter,$HeadingTranslation) = @_;
106 :    
107 :     my $DataHashRef = {};
108 :    
109 :     if (open (INPUT, "<$Filename")) {
110 :     while (my $Line = <INPUT>) {
111 :     chomp($Line);
112 :     my @Data = split(/$Delimiter/,$Line);
113 :     if (defined($HeadingTranslation) && defined($HeadingTranslation->{$Data[0]})) {
114 :     $DataHashRef->{"keytranslation"}->{$HeadingTranslation->{$Data[0]}} = $Data[0];
115 :     $Data[0] = $HeadingTranslation->{$Data[0]};
116 :     }
117 :     for (my $i=1; $i < @Data; $i++) {
118 :     $DataHashRef->{$Data[0]}->[$i-1] = $Data[$i];
119 :     }
120 :     if (@Data > 1) {
121 :     push(@{$DataHashRef->{"orderedkeys"}},$Data[0]);
122 :     }
123 :     }
124 :     close(INPUT);
125 :     } else {
126 :     die "Cannot open $Filename: $!";
127 :     }
128 :    
129 :     return $DataHashRef;
130 :     }
131 :    
132 :    
133 :     #--- This function loads a file containing a simple list and returns a reference to an array containing that list ---#
134 :     #--- Note that when a delimiter is supplied, each line in the file is broken up with the delimiter, and only the first element from each line is stored in the returned list ---#
135 :     sub LoadSingleColumnFile {
136 :     my ($Filename,$Delimiter) = @_;
137 :    
138 :     my $DataArrayRef = [];
139 :     if (open (INPUT, "<$Filename")) {
140 :     while (my $Line = <INPUT>) {
141 :     chomp($Line);
142 :    
143 :     if (length($Delimiter) > 0) {
144 :     my @Data = split(/$Delimiter/,$Line);
145 :     $Line = $Data[0];
146 :     }
147 :    
148 :     push(@{$DataArrayRef},$Line);
149 :     }
150 :     close(INPUT);
151 :     } else {
152 :     die "Cannot open $Filename: $!";
153 :     }
154 :     return $DataArrayRef;
155 :     }
156 :    
157 :     #--- This function loads a file containing multiple columns of data with no file headings ---#
158 :     sub LoadMultipleColumnFile {
159 :     my ($Filename,$Delimiter) = @_;
160 :    
161 :     my $DataArrayRefArrayRef = [];
162 :     if (open (INPUT, "<$Filename")) {
163 :     while (my $Line = <INPUT>) {
164 :     chomp($Line);
165 :     my $Data = [];
166 :     $Data->[0] = $Line;
167 :     if (length($Delimiter) > 0) {
168 :     @{$Data} = split(/$Delimiter/,$Line);
169 :     }
170 :     push(@{$DataArrayRefArrayRef},$Data);
171 :     }
172 :     close(INPUT);
173 :     } else {
174 :     die "Cannot open $Filename: $!";
175 :     }
176 :     return $DataArrayRefArrayRef;
177 :     }
178 :    
179 :     #--- This function loads a file containing multiple columns of data with file headings at the top ---#
180 :     sub LoadMultipleLabeledColumnFile {
181 :     my ($Filename,$ColumnDelimiter,$ItemDelimiter,$HeadingRowNumber) = @_;
182 :     if (!defined($HeadingRowNumber) || $HeadingRowNumber eq "") {
183 :     $HeadingRowNumber = 0;
184 :     }
185 :     my $DataHashRefArrayRef = [];
186 :     if (open (INPUT, "<$Filename")) {
187 :     my $Line = <INPUT>;
188 :     for (my $i=0; $i < $HeadingRowNumber; $i++) {
189 :     $Line = <INPUT>;
190 :     }
191 :     chomp($Line);
192 :     if (length($ColumnDelimiter) > 0) {
193 :     my @Headings = split(/$ColumnDelimiter/,$Line);
194 :     while ($Line = <INPUT>) {
195 :     chomp($Line);
196 :     my @Data = split(/$ColumnDelimiter/,$Line);
197 :     my $ArrayRefHashRef;
198 :     for (my $i=0; $i < @Headings; $i++) {
199 :     if (defined($Data[$i]) && length($Data[$i]) > 0) {
200 :     if (length($ItemDelimiter) > 0) {
201 :     my @TempArray = split(/$ItemDelimiter/,$Data[$i]);
202 :     foreach my $Item (@TempArray) {
203 :     push(@{$ArrayRefHashRef->{$Headings[$i]}},$Item);
204 :     }
205 :     } else {
206 :     $ArrayRefHashRef->{$Headings[$i]}->[0] = $Data[$i];
207 :     }
208 :     }
209 :     }
210 :     push(@{$DataHashRefArrayRef},$ArrayRefHashRef);
211 :     }
212 :     }
213 :     close(INPUT);
214 :     } else {
215 :     die "Cannot open $Filename: $!";
216 :     }
217 :     return $DataHashRefArrayRef;
218 :     }
219 :    
220 :     sub PrintHashArrayToFile {
221 :     my ($Filename,$HashArrayRef,$HeaderRef) = @_;
222 :    
223 :     if (open (HASHARRAYTOFILE, ">$Filename")) {
224 :     for (my $j=0; $j < @{$HeaderRef}; $j++) {
225 :     if ($j > 0) {
226 :     print HASHARRAYTOFILE "\t";
227 :     }
228 :     print HASHARRAYTOFILE $HeaderRef->[$j];
229 :     }
230 :     print HASHARRAYTOFILE "\n";
231 :     for (my $i=0; $i < @{$HashArrayRef}; $i++) {
232 :     for (my $j=0; $j < @{$HeaderRef}; $j++) {
233 :     if ($j > 0) {
234 :     print HASHARRAYTOFILE "\t";
235 :     }
236 :     if (defined($HashArrayRef->[$i]->{$HeaderRef->[$j]})) {
237 :     print HASHARRAYTOFILE join("|",@{$HashArrayRef->[$i]->{$HeaderRef->[$j]}});
238 :     }
239 :     }
240 :     print HASHARRAYTOFILE "\n";
241 :     }
242 :     close (HASHARRAYTOFILE);
243 :     }
244 :     }
245 :    
246 :     #--- This function loads a file with the following on each line: $A$Delimiter$B and maps $A to $B in the first returned hash reference and $B to $A in the second returned hash reference ---#
247 :     sub LoadSeparateTranslationFiles {
248 :     my ($Filename,$Delimiter) = @_;
249 :     my $HashReferenceForward = {};
250 :     my $HashReferenceReverse = {};
251 :    
252 :     if (open (INPUT, "<$Filename")) {
253 :     while (my $Line = <INPUT>) {
254 :     chomp($Line);
255 :     my @Data = split(/$Delimiter/,$Line);
256 :     if (@Data >= 2) {
257 :     $HashReferenceForward->{$Data[0]} = $Data[1];
258 :     $HashReferenceReverse->{$Data[1]} = $Data[0];
259 :     }
260 :     }
261 :     close(INPUT);
262 :     }
263 :    
264 :     return ($HashReferenceForward,$HashReferenceReverse);
265 :     }
266 :    
267 :     #--- This function breaks down the input filename into a directory, filename, and extension ---#
268 :     sub ParseFilename {
269 :     my ($Filename) = @_;
270 :    
271 :     my $Directory = "";
272 :     my $Extension = "";
273 :    
274 :     my $Position = rindex($Filename,"/");
275 :     my $SecondPosition = rindex($Filename,"\\");
276 :    
277 :     if ($SecondPosition > $Position) {
278 :     $Position = $SecondPosition;
279 :     }
280 :    
281 :     if ($Position > -1) {
282 :     $Directory = substr($Filename,0,$Position+1);
283 :     $Filename = substr($Filename,$Position+1,length($Filename)-$Position-1);
284 :     }
285 :    
286 :     $Position = index($Filename,".");
287 :     if ($Position > -1) {
288 :     $Extension = substr($Filename,$Position,length($Filename)-$Position);
289 :     $Filename = substr($Filename,0,$Position);
290 :     }
291 :    
292 :     return ($Filename,$Directory,$Extension);
293 :     }
294 :    
295 :     #--- This function compares the files listed in two separate directories and returns the list of new files and updated files ---#
296 :     sub CompareDirectories {
297 :     my ($NewDirectory,$OldDirectory,$ComparisonType) = @_;
298 :    
299 :     my $Command = "ls -la ".$NewDirectory." > ".$NewDirectory."FileList.txt";
300 :     system($Command);
301 :     $Command = "ls -la ".$OldDirectory." > ".$OldDirectory."FileList.txt";
302 :     system($Command);
303 :    
304 :     my $NewFileData = &LoadMultipleColumnFile($NewDirectory."FileList.txt","\\s");
305 :     my $OldFileData = &LoadMultipleColumnFile($OldDirectory."FileList.txt","\\s");
306 :    
307 :     my $UpdatedFiles = [];
308 :     my $NewFiles = [];
309 :    
310 :     my %FilenameHash;
311 :     foreach my $File (@{$OldFileData}) {
312 :     if ($ComparisonType eq "date") {
313 :     $FilenameHash{$File->[$#{$File}]} = $File->[$#{$File}-2].":".$File->[$#{$File}-1];
314 :     } elsif ($ComparisonType eq "size") {
315 :     $FilenameHash{$File->[$#{$File}]} = $File->[$#{$File}-3];
316 :     }
317 :     }
318 :     foreach my $File (@{$NewFileData}) {
319 :     if (defined($FilenameHash{$File->[$#{$File}]})) {
320 :     if ($ComparisonType eq "date" && $FilenameHash{$File->[$#{$File}]} ne $File->[$#{$File}-2].":".$File->[$#{$File}-1]) {
321 :     push(@{$UpdatedFiles},$File->[$#{$File}]);
322 :     } elsif ($ComparisonType eq "size" && $FilenameHash{$File->[$#{$File}]} ne $File->[$#{$File}-3]) {
323 :     push(@{$UpdatedFiles},$File->[$#{$File}]);
324 :     }
325 :     } else {
326 :     $FilenameHash{$File->[$#{$File}]} = $File->[$#{$File}-2].":".$File->[$#{$File}-1];
327 :     push(@{$NewFiles},$File->[$#{$File}]);
328 :     }
329 :     }
330 :    
331 :     return ($NewFiles,$UpdatedFiles);
332 :     }
333 :    
334 :     sub RemoveHFromFormula {
335 :     my ($Formula) = @_;
336 :     my @Data = split(/H/,$Formula);
337 :    
338 :     if (@Data == 1) {
339 :     return $Formula;
340 :     }
341 :    
342 :     while ($Data[1] =~ m/^\d/) {
343 :     $Data[1] = substr($Data[1],1);
344 :     }
345 :    
346 :     return $Data[0].$Data[1];
347 :     }
348 :    
349 :     sub CompareArrays {
350 :     my ($ArrayOne,$ArrayTwo) = @_;
351 :    
352 :     my $ArrayOneExtra = ();
353 :     my $ArrayTwoExtra = ();
354 :     my $ArrayOverlap = ();
355 :     my %ArrayTwoHash;
356 :    
357 :     for (my $i=0; $i < @{$ArrayOne}; $i++) {
358 :     my $Match = 0;
359 :     for (my $j=0; $j < @{$ArrayTwo}; $j++) {
360 :     if ($ArrayOne->[$i] eq $ArrayTwo->[$j]) {
361 :     $ArrayTwoHash{$ArrayOne->[$i]} = 1;
362 :     $Match = 1;
363 :     push(@{$ArrayOverlap},$ArrayOne->[$i]);
364 :     $j = @{$ArrayTwo};
365 :     }
366 :     }
367 :     if ($Match == 0) {
368 :     push(@{$ArrayOneExtra},$ArrayOne->[$i]);
369 :     }
370 :     }
371 :     for (my $j=0; $j < @{$ArrayTwo}; $j++) {
372 :     if (!defined($ArrayTwoHash{$ArrayTwo->[$j]})) {
373 :     push(@{$ArrayTwoExtra},$ArrayTwo->[$j]);
374 :     }
375 :     }
376 :    
377 :     return ($ArrayOneExtra,$ArrayTwoExtra,$ArrayOverlap);
378 :     }
379 :    
380 :     sub ReplaceLineSubstringsFromHash {
381 :     my ($Translation, $Line) = @_;
382 :    
383 :     my @Data = keys(%{$Translation});
384 :     for (my $i=0; $i < @Data; $i++) {
385 :     my $FindString = $Data[$i];
386 :     my $ReplaceString = $Translation->{$Data[$i]};
387 :     $Line =~ s/([\,\s\;\+\[])$FindString([\,\s\;\+\[])/$1$ReplaceString$2/g;
388 :     $Line =~ s/$FindString$/$ReplaceString/g;
389 :     $Line =~ s/^$FindString/$ReplaceString/g;
390 :     }
391 :    
392 :     return $Line;
393 :     }
394 :    
395 :     sub FindArrayElement {
396 :     my ($ArrayRef,$Value) = @_;
397 :    
398 :     if (!defined($ArrayRef)) {
399 :     return -1;
400 :     }
401 :    
402 :     for (my $i=0;$i < @{$ArrayRef};$i++) {
403 :     if ($ArrayRef->[$i] eq $Value) {
404 :     return $i;
405 :     }
406 :     }
407 :    
408 :     return -1;
409 :     }
410 :    
411 :     sub RemoveArrayElement {
412 :     my ($ArrayRef,$Value) = @_;
413 :    
414 :     for (my $i=0;$i < @{$ArrayRef};$i++) {
415 :     if ($ArrayRef->[$i] eq $Value) {
416 :     splice(@{$ArrayRef},$i,1);
417 :     $i--;
418 :     }
419 :     }
420 :    
421 :     return $ArrayRef;
422 :     }
423 :    
424 :     sub FormatNumber {
425 :     my ($OriginalNumber,$Digits,$ZeroEquivalence) = @_;
426 :    
427 :     if (abs($OriginalNumber) < $ZeroEquivalence) {
428 :     $OriginalNumber = "0.";
429 :     for (my $i=0; $i < $Digits;$i++) {
430 :     $OriginalNumber .= "0"
431 :     }
432 :     return $OriginalNumber
433 :     }
434 :    
435 :     if ($OriginalNumber > 1 || $OriginalNumber < -1) {
436 :     $OriginalNumber = $OriginalNumber*(10**$Digits);
437 :     $OriginalNumber = int($OriginalNumber + .5 * ($OriginalNumber <=> 0));
438 :     $OriginalNumber = $OriginalNumber/(10**$Digits);
439 :     return $OriginalNumber;
440 :     }
441 :    
442 :     my $Zeros = 0;
443 :     while (abs($OriginalNumber) < 10**$Zeros) {
444 :     $Zeros--;
445 :     }
446 :    
447 :     $OriginalNumber = $OriginalNumber*10**-$Zeros;
448 :     $OriginalNumber = $OriginalNumber*(10**$Digits);
449 :     $OriginalNumber = int($OriginalNumber + .5 * ($OriginalNumber <=> 0));
450 :     $OriginalNumber = $OriginalNumber/(10**$Digits);
451 :     if ($Zeros > -4) {
452 :     $OriginalNumber = $OriginalNumber/(10**-$Zeros);
453 :     } else {
454 :     $OriginalNumber .= "e".$Zeros;
455 :     }
456 :    
457 :     return $OriginalNumber;
458 :     }
459 :    
460 :     sub ConvertToSearchNames {
461 :     my ($InName) = @_;
462 :    
463 :     if ($InName =~ m/-$/) {
464 :     return $InName;
465 :     }
466 :    
467 :     #I convert all names to lowercase to help with matching
468 :     $InName = lc($InName);
469 :     #I remove all spaces from all names to help with matching
470 :     $InName =~ s/\s//g;
471 :     $InName =~ s/-//g;
472 :     $InName =~ s/_//g;
473 :     $InName =~ s/\(//g;
474 :     $InName =~ s/\)//g;
475 :     $InName =~ s/\[//g;
476 :     $InName =~ s/\]//g;
477 :     $InName =~ s/\://g;
478 :     $InName =~ s/\;//g;
479 :    
480 :     my $NameOne = $InName;
481 :     $InName =~ s/icacid/ate/g;
482 :     if ($NameOne eq $InName) {
483 :     return ($NameOne);
484 :     } else {
485 :     return ($NameOne,$InName);
486 :     }
487 :     }
488 :     sub CountFileLines {
489 :     my ($filename) = @_;
490 :     my $lines = 0;
491 :     open(FILE, $filename) or die "Can't open `$filename': $!";
492 :     while(<FILE>) {
493 :     $lines++;
494 :     }
495 :     close FILE;
496 :     return $lines;
497 :     }
498 :    
499 :     sub ManipulateFormula {
500 :     my ($OriginalFormula) = @_;
501 :    
502 :     my %Atoms;
503 :     my $CurrentAtomType = "";
504 :     my $CurrentAtomNumber = "";
505 :     for (my $i=0; $i < length($OriginalFormula); $i++) {
506 :     my $CurrentLetter = substr($OriginalFormula,$i,1);
507 :     if ($CurrentLetter =~ m/[A-Z]/) {
508 :     if ($CurrentAtomType ne "") {
509 :     if ($CurrentAtomNumber eq "1") {
510 :     $CurrentAtomNumber = "";
511 :     }
512 :     $Atoms{$CurrentAtomType} = $CurrentAtomNumber;
513 :     }
514 :     $CurrentAtomType = $CurrentLetter;
515 :     $CurrentAtomNumber = "";
516 :     } elsif ($CurrentLetter =~ m/[a-z]/) {
517 :     $CurrentAtomType .= $CurrentLetter;
518 :     } elsif ($CurrentLetter =~ m/[\d]/) {
519 :     $CurrentAtomNumber .= $CurrentLetter;
520 :     } else {
521 :     if ($CurrentAtomType ne "") {
522 :     $Atoms{$CurrentAtomType} = $CurrentAtomNumber;
523 :     }
524 :     $CurrentAtomType = "";
525 :     }
526 :     }
527 :     if ($CurrentAtomType ne "") {
528 :     if ($CurrentAtomNumber eq "1") {
529 :     $CurrentAtomNumber = "";
530 :     }
531 :     $Atoms{$CurrentAtomType} = $CurrentAtomNumber;
532 :     }
533 :    
534 :     my @SortedAtoms = sort(keys(%Atoms));
535 :     my $StandardFormula;
536 :     my $CompareFormula;
537 :     for (my $i=0; $i < @SortedAtoms; $i++) {
538 :     $StandardFormula .= $SortedAtoms[$i];
539 :     $StandardFormula .= $Atoms{$SortedAtoms[$i]};
540 :     if ($SortedAtoms[$i] ne "H") {
541 :     $CompareFormula .= $SortedAtoms[$i];
542 :     $CompareFormula .= $Atoms{$SortedAtoms[$i]};
543 :     }
544 :     }
545 :    
546 :     return ($StandardFormula,$CompareFormula);
547 :     }
548 :    
549 :    
550 :    
551 :     sub ParseGPRFile {
552 :     my ($Filename,$ReactionData) = @_;
553 :    
554 :     my $GPRData = &LoadMultipleColumnFile($Filename,"\t");
555 :    
556 :     for (my $i=0; $i < @{$GPRData}; $i++) {
557 :     if (@{$GPRData->[$i]} >= 3) {
558 :     if (!defined($ReactionData->{$GPRData->[$i]->[2]})) {
559 :     $ReactionData->{$GPRData->[$i]->[2]}->{"ID"} = $GPRData->[$i]->[2];
560 :     }
561 :     if (length($GPRData->[$i]->[1]) > 0) {
562 :     $ReactionData->{$GPRData->[$i]->[2]}->{"EC"} = $GPRData->[$i]->[1];
563 :     }
564 :     for (my $j=4; $j < @{$GPRData->[$i]}; $j++) {
565 :     if (length($GPRData->[$i]->[$j]) > 0) {
566 :     if ($GPRData->[$i]->[$j] =~ m/_$/) {
567 :     $GPRData->[$i]->[$j] = chop($GPRData->[$i]->[$j]);
568 :     }
569 :     push(@{$ReactionData->{$GPRData->[$i]->[2]}->{"GENE ID"}},$GPRData->[$i]->[$j]);
570 :     }
571 :     }
572 :     }
573 :     }
574 :    
575 :     return ($ReactionData);
576 :     }
577 :    
578 :     sub ParseSBMLFile {
579 :     my ($Filename,$ReactionData,$CompoundData) = @_;
580 :    
581 :     my $SBMLData = &LoadSingleColumnFile($Filename,"");
582 :    
583 :     my $HandlingSpecies = 0;
584 :     my $HandlingReactions = 0;
585 :     my $HandlingReactants = 0;
586 :     my $HandlingProducts = 0;
587 :     my $ReactionID = "";
588 :     my $ReactionReactants = "";
589 :     my $ReactionSign = "";
590 :     my $ReactionProducts = "";
591 :     for (my $i=0; $i < @{$SBMLData}; $i++) {
592 :     if ($SBMLData->[$i] =~ m/^<listOfSpecies>/) {
593 :     $HandlingSpecies = 1;
594 :     } elsif ($SBMLData->[$i] =~ m/^<\/listOfSpecies>/) {
595 :     $HandlingSpecies = 0;
596 :     } elsif ($SBMLData->[$i] =~ m/^<listOfReactions>/) {
597 :     $HandlingReactions = 1;
598 :     } elsif ($SBMLData->[$i] =~ m/^<\/listOfReactions>/) {
599 :     $HandlingReactions = 0;
600 :     } elsif ($HandlingSpecies == 1 && $SBMLData->[$i] =~ m/^<species/) {
601 :     #Parsing out the compound ID
602 :     if ($SBMLData->[$i] =~ m/id="([^"]+)"/) {
603 :     my $ID = $1;
604 :     if ($ID =~ m/^_/) {
605 :     $ID = substr($ID,1);
606 :     }
607 :     if ($ID =~ m/_[a-z]$/) {
608 :     chop($ID);
609 :     chop($ID);
610 :     }
611 :     if (length($ID) > 0) {
612 :     #Parsing out the compound name
613 :     if (!defined($CompoundData->{$ID})) {
614 :     $CompoundData->{$ID}->{"ID"} = $ID;
615 :     }
616 :     if ($SBMLData->[$i] =~ m/name="([^"]+)"/) {
617 :     my $Name = $1;
618 :     if ($Name =~ m/^_/) {
619 :     $Name = substr($Name,1);
620 :     }
621 :     $Name =~ s/_/ /g;
622 :     if (length($Name) > 0 && (!defined($CompoundData->{$ID}->{"NAME"}) || &FindArrayElement($CompoundData->{$ID}->{"NAME"},$Name) == -1)) {
623 :     push(@{$CompoundData->{$ID}->{"NAME"}},$Name);
624 :     }
625 :     }
626 :     }
627 :     }
628 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<reaction/) {
629 :     $ReactionSign = " <=> ";
630 :     if ($SBMLData->[$i] =~ m/reversible="false"/) {
631 :     $ReactionSign = " => ";
632 :     }
633 :     if ($SBMLData->[$i] =~ m/id="([^"]+)"/) {
634 :     $ReactionID = $1;
635 :     if (length($ReactionID) > 0) {
636 :     if (!defined($ReactionData->{$ReactionID})) {
637 :     $ReactionData->{$ReactionID}->{"ID"} = $ReactionID;
638 :     }
639 :     if ($SBMLData->[$i] =~ m/name="([^"]+)"/) {
640 :     my $Name = $1;
641 :     if ($Name =~ m/^_/) {
642 :     $Name = substr($Name,1);
643 :     }
644 :     $Name =~ s/_/ /g;
645 :     if (length($Name) > 0 && (!defined($ReactionData->{$ReactionID}->{"NAME"}) || &FindArrayElement($ReactionData->{$ReactionID}->{"NAME"},$Name) == -1)) {
646 :     push(@{$ReactionData->{$ReactionID}->{"NAME"}},$Name);
647 :     }
648 :     }
649 :    
650 :     }
651 :     }
652 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<\/reaction>/) {
653 :     $ReactionID = "";
654 :     $ReactionReactants = "";
655 :     $ReactionSign = "";
656 :     $ReactionProducts = "";
657 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<html:p>EC Number:\s([^<]+)/) {
658 :     my $ECNumber = $1;
659 :     if (length($ECNumber) > 3 && (!defined($ReactionData->{$ReactionID}->{"EC"}) || &FindArrayElement($ReactionData->{$ReactionID}->{"EC"},$ECNumber) == -1)) {
660 :     push(@{$ReactionData->{$ReactionID}->{"EC"}},$ECNumber);
661 :     }
662 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<html:p>Confidence Level:\s([^<]+)/) {
663 :     my $Confidence = $1;
664 :     if (length($Confidence) > 0) {
665 :     $ReactionData->{$ReactionID}->{"CONFIDENCE"} = $Confidence;
666 :     }
667 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<html:p>LOCUS:/) {
668 :     $_ = $SBMLData->[$i];
669 :     my @GeneArray = /<html:p>LOCUS:([^\#]+)/g;
670 :     for (my $j=0; $j < @GeneArray; $j++) {
671 :     if (length($GeneArray[$j]) > 0 && (!defined($ReactionData->{$ReactionID}->{"GENES"}) || &FindArrayElement($ReactionData->{$ReactionID}->{"GENES"},$GeneArray[$j]) == -1)) {
672 :     push(@{$ReactionData->{$ReactionID}->{"GENES"}},$GeneArray[$j]);
673 :     }
674 :     }
675 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<listOfReactants>/) {
676 :     $HandlingReactants = 1;
677 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<\/listOfReactants>/) {
678 :     $HandlingReactants = 0;
679 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<listOfProducts>/) {
680 :     $HandlingProducts = 1;
681 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<\/listOfProducts>/) {
682 :     $HandlingProducts = 0;
683 :     if (length($ReactionID) > 0 && defined($ReactionData->{$ReactionID})) {
684 :     my $Equation = $ReactionReactants.$ReactionSign.$ReactionProducts;
685 :     $ReactionData->{$ReactionID}->{"EQUATION"} = $Equation;
686 :     }
687 :     } elsif ($HandlingReactions == 1 && $SBMLData->[$i] =~ m/^<speciesReference/) {
688 :     if ($SBMLData->[$i] =~ m/species="([^"]+)"/) {
689 :     my $SpeciesID = $1;
690 :     if ($SpeciesID =~ m/^_/) {
691 :     $SpeciesID = substr($SpeciesID,1);
692 :     }
693 :     my $Compartment = "";
694 :     if ($SpeciesID =~ m/_([a-z])$/) {
695 :     $Compartment = $1;
696 :     chop($SpeciesID);
697 :     chop($SpeciesID);
698 :     }
699 :     my $Stoichiometry = "";
700 :     if ($SBMLData->[$i] =~ m/stoichiometry="([^"]+)"/) {
701 :     $Stoichiometry = $1;
702 :     }
703 :     if (length($Stoichiometry) > 0 && length($SpeciesID) > 0) {
704 :     my $SpeciesString = "";
705 :     if ($Stoichiometry ne "1") {
706 :     $SpeciesString .= "(".$Stoichiometry.") ";
707 :     }
708 :     $SpeciesString .= "$SpeciesID";
709 :     if (length($Compartment) > 0 && $Compartment ne "c") {
710 :     $SpeciesString .= "[".$Compartment."]";
711 :     }
712 :     if ($HandlingReactants == 1) {
713 :     if (length($ReactionReactants) > 0) {
714 :     $ReactionReactants .= " + ";
715 :     }
716 :     $ReactionReactants .= $SpeciesString;
717 :     } elsif ($HandlingProducts == 1) {
718 :     if (length($ReactionProducts) > 0) {
719 :     $ReactionProducts .= " + ";
720 :     }
721 :     $ReactionProducts .= $SpeciesString;
722 :     }
723 :     }
724 :     }
725 :     }
726 :     }
727 :    
728 :     return ($ReactionData,$CompoundData);
729 :     }
730 :    
731 :     sub SearchTranslationDataForMatchingID {
732 :     my ($Filename,$SearchText) = @_;
733 :    
734 :     #Declaring the reference to the array where the results will ultimately be stored
735 :     my $MatchingIDs = ();
736 :    
737 :     #If the search text is blank or the input file does not exist, I return an empty array
738 :     if (length($SearchText) == 0 || !(-e $Filename)) {
739 :     return $MatchingIDs;
740 :     }
741 :    
742 :     #Loading the translation file
743 :     my %IDHash;
744 :     my $TranslationData = &LoadMultipleColumnFile($Filename,"\t");
745 :     my %UniqueKeysHash;
746 :     for (my $i=0; $i < @{$TranslationData}; $i++) {
747 :     if (@{$TranslationData->[$i]} >= 2) {
748 :     push(@{$UniqueKeysHash{$TranslationData->[$i]->[1]}},$TranslationData->[$i]->[0]);
749 :     }
750 :     }
751 :     #Searching through the keys of the translation file for my search text and storing matching ids in a hash
752 :     my @AllKeys = keys(%UniqueKeysHash);
753 :     for (my $i=0; $i < @AllKeys; $i++) {
754 :     if ($AllKeys[$i] =~ m/$SearchText/) {
755 :     for (my $j=0; $j < @{$UniqueKeysHash{$AllKeys[$i]}}; $j++) {
756 :     $IDHash{$UniqueKeysHash{$AllKeys[$i]}->[$j]} = 1;
757 :     }
758 :     }
759 :     }
760 :    
761 :     #Putting the matching hash keys into an array and sorting it
762 :     push(@{$MatchingIDs},keys(%IDHash));
763 :     if (defined($MatchingIDs)) {
764 :     @{$MatchingIDs} = sort(@{$MatchingIDs})
765 :     }
766 :    
767 :     return $MatchingIDs;
768 :     }
769 :    
770 :     sub BackupFile {
771 :     my ($CurrentFilename,$BackupFilename) = @_;
772 :    
773 :     if (-e $CurrentFilename) {
774 :     if (-e $BackupFilename) {
775 :     unlink($BackupFilename);
776 :     }
777 :     rename($CurrentFilename,$BackupFilename);
778 :     }
779 :     }
780 :    
781 :     sub Date {
782 :     my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
783 :     return ($mon+1)."/".($mday+1)."/".($year+1900);
784 :     }
785 :    
786 :     sub MergeArraysUnique {
787 :     my @ArrayRefs = @_;
788 :    
789 :     my $ResultArray = ();
790 :     my %EntryHash;
791 :     for (my $i=0; $i < @ArrayRefs; $i++) {
792 :     if (defined($ArrayRefs[$i])) {
793 :     for (my $j=0; $j < @{$ArrayRefs[$i]}; $j++) {
794 :     if (!defined($EntryHash{$ArrayRefs[$i]->[$j]})) {
795 :     push(@{$ResultArray},$ArrayRefs[$i]->[$j]);
796 :     $EntryHash{$ArrayRefs[$i]->[$j]} = 1;
797 :     }
798 :     }
799 :     }
800 :     }
801 :    
802 :     return $ResultArray
803 :     }
804 :    
805 :     #Opens up every file in a directory, searches each line for the search expression, and replaces the objects matching the search expression according to the translation hash
806 :     sub TranslateFileData {
807 :     my ($TranslationHash,$FilenameExpression,$SearchExpression,$Recursive,$MakeUnique,$SortLines) = @_;
808 :    
809 :     #Checking the search expression if one was provided
810 :     if (defined($SearchExpression) && length($SearchExpression) > 0) {
811 :     if (index($SearchExpression,"(") == -1 || index($SearchExpression,"(") == -1) {
812 :     $SearchExpression = "(".$SearchExpression.")";
813 :     }
814 :     }
815 :    
816 :     #Finding all matching filenames
817 :     my @MatchingFiles;
818 :     if ($Recursive == 1 && $FilenameExpression =~ m/\/$/) {
819 :     @MatchingFiles = &RecursiveGlob($FilenameExpression);
820 :     } else {
821 :     @MatchingFiles = glob($FilenameExpression);
822 :     }
823 :    
824 :     #Exiting if no matching filenames were found
825 :     if (@MatchingFiles == 0) {
826 :     print "No matching files!\n";
827 :     return;
828 :     }
829 :    
830 :     #Loading the translation file
831 :     if (!(-e $TranslationHash)) {
832 :     print "Could not find translation file: ".$TranslationHash."!\n";
833 :     return;
834 :     }
835 :     my ($Ignore,$ReverseTranslation) = &LoadSeparateTranslationFiles($TranslationHash,"\t");
836 :    
837 :     #Scanning through all matching filenames
838 :     my @TranslationKeys = keys(%{$ReverseTranslation});
839 :    
840 :     for (my $i=0; $i < @MatchingFiles; $i++) {
841 :     #Loading the file data into an array
842 :     my $FileData = &LoadSingleColumnFile($MatchingFiles[$i],"");
843 :     #Scanning through each fileline
844 :     my $MatchCount = 0;
845 :     for (my $j=0; $j < @{$FileData}; $j++) {
846 :     if (defined($SearchExpression) && length($SearchExpression) > 0) {
847 :     #This should be faster
848 :     $_ = $FileData->[$j];
849 :     my @MatchingGroups = /$SearchExpression/g;
850 :     for (my $k=0; $k < @MatchingGroups;$k++) {
851 :     if (defined($ReverseTranslation->{$MatchingGroups[$k]})) {
852 :     $MatchCount++;
853 :     my $VarOne = $MatchingGroups[$k];
854 :     my $VarTwo = $ReverseTranslation->{$MatchingGroups[$k]};
855 :     $FileData->[$j] =~ s/$VarOne/$VarTwo/;
856 :     }
857 :     }
858 :     } else {
859 :     #This will be slower
860 :     for (my $k=0; $k < @TranslationKeys;$k++) {
861 :     my $VarOne = $TranslationKeys[$k];
862 :     my $VarTwo = $ReverseTranslation->{$TranslationKeys[$k]};
863 :     $FileData->[$j] =~ s/$VarOne/$VarTwo/g;
864 :     }
865 :     }
866 :    
867 :     }
868 :     #Saving the modified file data back to the file
869 :     print $MatchingFiles[$i]."\n";
870 :     print $MatchCount."\n";
871 :     #Making the array unique if requested
872 :     if (defined($MakeUnique) && $MakeUnique == 1) {
873 :     $FileData = &MergeArraysUnique($FileData);
874 :     }
875 :     #Sort file lines
876 :     if (defined($SortLines) && $SortLines == 1) {
877 :     @{$FileData} = sort(@{$FileData});
878 :     }
879 :     &PrintArrayToFile($MatchingFiles[$i],$FileData);
880 :     }
881 :     }
882 :    
883 :     sub RecursiveGlob {
884 :     my($path) = @_;
885 :    
886 :     my @FileList;
887 :    
888 :     ## append a trailing / if it's not there
889 :     $path .= '/' if($path !~ /\/$/);
890 :    
891 :     ## loop through the files contained in the directory
892 :     for my $eachFile (glob($path.'*')) {
893 :     ## if the file is a directory
894 :     if( -d $eachFile) {
895 :     ## pass the directory to the routine ( recursion )
896 :     push(@FileList,RecursiveGlob($eachFile));
897 :     } else {
898 :     push(@FileList,$eachFile);
899 :     }
900 :     }
901 :    
902 :     return @FileList;
903 :     }
904 :    
905 :     sub PrintHashToFile {
906 :     my($HashRef,$Filename) = @_;
907 :    
908 :     if ($Filename == "") {
909 :     open (HASHOUTPUT, ">&STDOUT");
910 :     } else {
911 :     open (HASHOUTPUT, ">$Filename");
912 :     }
913 :     my @Headings = keys(%{$HashRef});
914 :     my @FirstHeadings;
915 :     my @SecondHeadings;
916 :     for (my $i=0; $i < @Headings; $i++) {
917 :     if (ref($HashRef->{$Headings[$i]}) eq "HASH") {
918 :     my @SubHeadings = keys(%{$HashRef->{$Headings[$i]}});
919 :     for (my $j=0; $j < @SubHeadings;$j++) {
920 :     push(@FirstHeadings,$Headings[$i]);
921 :     push(@SecondHeadings,$SubHeadings[$j]);
922 :     }
923 :     } else {
924 :     push(@FirstHeadings,$Headings[$i]);
925 :     push(@SecondHeadings,$Headings[$i]);
926 :     }
927 :     }
928 :     #Printing headers
929 :     print HASHOUTPUT "FIRST HEADING;";
930 :     print HASHOUTPUT join(";",@FirstHeadings)."\n";
931 :     print HASHOUTPUT "SECOND HEADING;";
932 :     print HASHOUTPUT join(";",@SecondHeadings)."\n";
933 :     #Printing the number of data entries
934 :     print HASHOUTPUT "Number of entries;";
935 :     for (my $i=0; $i < @FirstHeadings; $i++) {
936 :     if ($i > 0) {
937 :     print HASHOUTPUT ";";
938 :     }
939 :     if ($FirstHeadings[$i] ne $SecondHeadings[$i]) {
940 :     if (defined($HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]})) {
941 :     if (@{$HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}} == 1) {
942 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}->[0];
943 :     } else {
944 :     my $NumEntries = @{$HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}};
945 :     print HASHOUTPUT $NumEntries;
946 :     }
947 :     } else {
948 :     print HASHOUTPUT 0;
949 :     }
950 :     } else {
951 :     if (defined($HashRef->{$FirstHeadings[$i]})) {
952 :     if (@{$HashRef->{$FirstHeadings[$i]}} == 1) {
953 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->[0];
954 :     } else {
955 :     my $NumEntries = @{$HashRef->{$FirstHeadings[$i]}};
956 :     print HASHOUTPUT $NumEntries;
957 :     }
958 :     } else {
959 :     print HASHOUTPUT 0;
960 :     }
961 :     }
962 :     }
963 :     print HASHOUTPUT "\n";
964 :     #Printing data
965 :     my $Continue = 1;
966 :     my $Count = 0;
967 :     while($Continue == 1) {
968 :     print HASHOUTPUT ($Count+1).";";
969 :     $Continue = 0;
970 :     for (my $i=0; $i < @FirstHeadings; $i++) {
971 :     if ($FirstHeadings[$i] ne $SecondHeadings[$i]) {
972 :     if (defined($HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]})) {
973 :     if (@{$HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}} > 1 && defined($HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}->[$Count])) {
974 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->{$SecondHeadings[$i]}->[$Count];
975 :     $Continue = 1;
976 :     }
977 :     }
978 :     } else {
979 :     if (defined($HashRef->{$FirstHeadings[$i]})) {
980 :     if (@{$HashRef->{$FirstHeadings[$i]}} > 1 && defined($HashRef->{$FirstHeadings[$i]}->[$Count])) {
981 :     print HASHOUTPUT $HashRef->{$FirstHeadings[$i]}->[$Count];
982 :     $Continue = 1;
983 :     }
984 :     }
985 :     }
986 :     print HASHOUTPUT ";";
987 :     }
988 :     $Count++;
989 :     print HASHOUTPUT "\n";
990 :     }
991 :     close(HASHOUTPUT);
992 :     }
993 :    
994 :     sub CreateHistogramHash {
995 :     my($ArrayRef) = @_;
996 :    
997 :     my $HashRef;
998 :     for (my $i=0; $i < @{$ArrayRef}; $i++) {
999 :     my @TempArray = split(/\|/,$ArrayRef->[$i]);
1000 :     for (my $j=0; $j < @TempArray; $j++) {
1001 :     if (defined($HashRef->{$TempArray[$j]})) {
1002 :     $HashRef->{$TempArray[$j]}->[0]++;
1003 :     } else {
1004 :     $HashRef->{$TempArray[$j]}->[0] = 1;
1005 :     }
1006 :     }
1007 :     }
1008 :    
1009 :     return $HashRef;
1010 :     }
1011 :    
1012 :     #init_hoh will take a directory like peg or rxn and create a hash of hashes
1013 :     #my $dir_all = '/disks/www/Network_Data/MinOrg';
1014 :     #$dir_peg = "$dir_all/peg";
1015 :     #%hoh_peg = &init_hoh($dir_peg);
1016 :     # $hoh_peg{'peg.1234'}{REACTIONS} will be an @array of reactions associated with peg.1234
1017 :     sub init_hoh{
1018 :     my $dir = shift @_;
1019 :     my %hash;
1020 :     opendir my $DH, $dir or die "cannot open '$dir' $!";
1021 :     while (my $file = readdir $DH ) {
1022 :     chomp $file;
1023 :     next if $file =~ /~$/;
1024 :     next if -d $file;
1025 :     open my $FH, "<", "$dir/$file" or die "Cannot open '$dir/$file' $!";
1026 :     while ( my $line = <$FH> ) {
1027 :     chomp $line;
1028 :     next if /^#/ || !length($line);
1029 :     my ($key, @values ) = split(/\t/, $line);
1030 :     $hash{ $file }{ $key } = \@values;
1031 :     }
1032 :     close $FH;
1033 :     }
1034 :     return %hash;
1035 :     }
1036 :    
1037 :     sub AddElementsUnique {
1038 :     my ($ArrayRef,@NewElements) = @_;
1039 :    
1040 :     my $ArrayValueHash;
1041 :     my $NewArray;
1042 :     if (defined($ArrayRef) && @{$ArrayRef} > 0) {
1043 :     for (my $i=0; $i < @$ArrayRef; $i++) {
1044 :     if (!defined($ArrayValueHash->{$ArrayRef->[$i]})) {
1045 :     push(@{$NewArray},$ArrayRef->[$i]);
1046 :     $ArrayValueHash->{$ArrayRef->[$i]} = @{$NewArray}-1;
1047 :     }
1048 :     }
1049 :     }
1050 :    
1051 :     my $NumberOfMatches = 0;
1052 :     for (my $i=0; $i < @NewElements; $i++) {
1053 :     if (length($NewElements[$i]) > 0 && !defined($ArrayValueHash->{$NewElements[$i]})) {
1054 :     push(@{$NewArray},$NewElements[$i]);
1055 :     $ArrayValueHash->{$NewElements[$i]} = @{$NewArray}-1;
1056 :     } else {
1057 :     $NumberOfMatches++;
1058 :     }
1059 :     }
1060 :    
1061 :     return ($NewArray,$NumberOfMatches);
1062 :     }
1063 :    
1064 :     sub PutArrayInHash {
1065 :     my ($ArrayRef) = @_;
1066 :    
1067 :     my $HashRef;
1068 :     for (my $i=0; $i < @{$ArrayRef}; $i++) {
1069 :     $HashRef->{$ArrayRef->[$i]} = $i;
1070 :     }
1071 :    
1072 :     return $HashRef;
1073 :     }
1074 :    
1075 :     1;

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3