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

Annotation of /FigKernelPackages/FileIOFunctions.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3