Mercurial > repos > deepakjadmin > mayatool3_test2

comparison lib/SDFileUtil.pm @ 0:4816e4a8ae95 draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded
author deepakjadmin
date Wed, 20 Jan 2016 09:23:18 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4816e4a8ae95
1 package SDFileUtil;
2 #
3 # $RCSfile: SDFileUtil.pm,v $
4 # $Date: 2015/02/28 20:47:18 $
5 # $Revision: 1.49 $
6 #
7 # Author: Manish Sud <msud@san.rr.com>
8 #
9 # Copyright (C) 2015 Manish Sud. All rights reserved.
10 #
11 # This file is part of MayaChemTools.
12 #
13 # MayaChemTools is free software; you can redistribute it and/or modify it under
14 # the terms of the GNU Lesser General Public License as published by the Free
15 # Software Foundation; either version 3 of the License, or (at your option) any
16 # later version.
17 #
18 # MayaChemTools is distributed in the hope that it will be useful, but without
19 # any warranty; without even the implied warranty of merchantability of fitness
20 # for a particular purpose. See the GNU Lesser General Public License for more
21 # details.
22 #
23 # You should have received a copy of the GNU Lesser General Public License
24 # along with MayaChemTools; if not, see <http://www.gnu.org/licenses/> or
25 # write to the Free Software Foundation Inc., 59 Temple Place, Suite 330,
26 # Boston, MA, 02111-1307, USA.
27 #
28
29 use strict;
30 use Exporter;
31 use Carp;
32 use PeriodicTable qw(IsElement);
33 use TimeUtil ();
34
35 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
36
37 @ISA = qw(Exporter);
38 @EXPORT = qw(GenerateCmpdAtomLine GenerateCmpdBondLine GenerateCmpdChargePropertyLines GenerateCmpdCommentsLine GenerateCmpdCountsLine GenerateCmpdAtomAliasPropertyLines GenerateCmpdIsotopePropertyLines GenerateCmpdDataHeaderLabelsAndValuesLines GenerateCmpdMiscInfoLine GenerateCmpdRadicalPropertyLines GenerateCmpdMolNameLine GenerateEmptyCtabBlockLines GenerateMiscLineDateStamp GetAllAndCommonCmpdDataHeaderLabels GetCmpdDataHeaderLabels GetCmpdDataHeaderLabelsAndValues GetCmpdFragments GetCtabLinesCount GetUnknownAtoms GetInvalidAtomNumbers MDLChargeToInternalCharge InternalChargeToMDLCharge MDLBondTypeToInternalBondOrder InternalBondOrderToMDLBondType MDLBondStereoToInternalBondStereochemistry InternalBondStereochemistryToMDLBondStereo InternalSpinMultiplicityToMDLRadical MDLRadicalToInternalSpinMultiplicity IsCmpd3D IsCmpd2D ParseCmpdAtomLine ParseCmpdBondLine ParseCmpdCommentsLine ParseCmpdCountsLine ParseCmpdMiscInfoLine ParseCmpdMolNameLine ParseCmpdAtomAliasPropertyLine ParseCmpdChargePropertyLine ParseCmpdIsotopePropertyLine ParseCmpdRadicalPropertyLine ReadCmpdString RemoveCmpdDataHeaderLabelAndValue WashCmpd);
39 @EXPORT_OK = qw();
40 %EXPORT_TAGS = (all => [@EXPORT, @EXPORT_OK]);
41
42 # Format data for compounds count line...
43 sub GenerateCmpdCountsLine {
44 my($AtomCount, $BondCount, $ChiralFlag, $PropertyCount, $Version, $Line);
45
46 if (@_ == 5) {
47 ($AtomCount, $BondCount, $ChiralFlag, $PropertyCount, $Version) = @_;
48 }
49 elsif (@_ == 3) {
50 ($AtomCount, $BondCount, $ChiralFlag) = @_;
51 $PropertyCount = 999;
52 $Version = "V2000";
53 }
54 else {
55 ($AtomCount, $BondCount) = @_;
56 $ChiralFlag = 0;
57 $PropertyCount = 999;
58 $Version = "V2000";
59 }
60 if ($AtomCount > 999) {
61 croak "Error: SDFileUtil::GenerateCmpdCountsLine: The atom count, $AtomCount, exceeds maximum of 999 allowed for CTAB version 2000. The Extended Connection Table (V3000) format in MDL MOL and SD files is not supported by the current release of MayaChemTools...";
62 }
63 $Line = sprintf "%3i%3i%3i%3i%3i%3i%3i%3i%3i%3i%3i%6s", $AtomCount, $BondCount, 0, 0, $ChiralFlag, 0, 0, 0, 0, 0, $PropertyCount, $Version;
64
65 return ($Line);
66 }
67
68 # Generate comments line...
69 sub GenerateCmpdCommentsLine {
70 my($Comments) = @_;
71 my($Line);
72
73 $Line = (length($Comments) > 80) ? substr($Comments, 0, 80) : $Comments;
74
75 return $Line;
76 }
77
78 # Generate molname line...
79 sub GenerateCmpdMolNameLine {
80 my($MolName) = @_;
81 my($Line);
82
83 $Line = (length($MolName) > 80) ? substr($MolName, 0, 80) : $MolName;
84
85 return $Line;
86 }
87
88 # Generate data for compounds misc info line...
89 sub GenerateCmpdMiscInfoLine {
90 my($ProgramName, $UserInitial, $Code) = @_;
91 my($Date, $Line);
92
93 if (!(defined($ProgramName) && $ProgramName)) {
94 $ProgramName = "MayaChem";
95 }
96 if (!(defined($UserInitial) && $UserInitial)) {
97 $UserInitial = " ";
98 }
99 if (!(defined($Code) && $Code)) {
100 $Code = "2D";
101 }
102
103 if (length($ProgramName) > 8) {
104 $ProgramName = substr($ProgramName, 0, 8);
105 }
106 if (length($UserInitial) > 2) {
107 $UserInitial = substr($UserInitial, 0, 2);
108 }
109 if (length($Code) > 2) {
110 $Code = substr($Code, 0, 2);
111 }
112 $Date = GenerateMiscLineDateStamp();
113
114 $Line = "${UserInitial}${ProgramName}${Date}${Code}";
115
116 return $Line;
117 }
118
119 # Generate data for compounds misc info line...
120 sub GenerateEmptyCtabBlockLines {
121 my($Date, $Lines);
122
123 if (@_ == 1) {
124 ($Date) = @_;
125 }
126 else {
127 $Date = GenerateMiscLineDateStamp();
128 }
129 # First line: Blank molname line...
130 # Second line: Misc info...
131 # Third line: Blank comments line...
132 # Fourth line: Counts line reflecting empty structure data block...
133 $Lines = "\n";
134 $Lines .= " MayaChem${Date}2D\n";
135 $Lines .= "\n";
136 $Lines .= GenerateCmpdCountsLine(0, 0, 0) . "\n";
137 $Lines .= "M END";
138
139 return $Lines;
140 }
141
142 # Generate SD file data stamp...
143 sub GenerateMiscLineDateStamp {
144 return TimeUtil::SDFileTimeStamp();
145 }
146
147 # Generate data for compound atom line...
148 #
149 sub GenerateCmpdAtomLine {
150 my($AtomSymbol, $AtomX, $AtomY, $AtomZ, $MassDifference, $Charge, $StereoParity) = @_;
151 my($Line);
152
153 if (!defined $MassDifference) {
154 $MassDifference = 0;
155 }
156 if (!defined $Charge) {
157 $Charge = 0;
158 }
159 if (!defined $StereoParity) {
160 $StereoParity = 0;
161 }
162 $Line = sprintf "%10.4f%10.4f%10.4f %-3s%2i%3i%3i 0 0 0 0 0 0 0 0 0", $AtomX, $AtomY, $AtomZ, $AtomSymbol, $MassDifference, $Charge, $StereoParity;
163
164 return $Line
165 }
166
167 # Generate data for compound bond line...
168 #
169 sub GenerateCmpdBondLine {
170 my($FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo) = @_;
171 my($Line);
172
173 if (!defined $BondStereo) {
174 $BondStereo = 0;
175 }
176 $Line = sprintf "%3i%3i%3i%3i 0 0 0", $FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo;
177
178 return $Line
179 }
180
181 # Generate charge property lines for CTAB block...
182 #
183 sub GenerateCmpdChargePropertyLines {
184 my($ChargeValuePairsRef) = @_;
185
186 return _GenerateCmpdGenericPropertyLines('Charge', $ChargeValuePairsRef);
187 }
188
189 # Generate isotope property lines for CTAB block...
190 #
191 sub GenerateCmpdIsotopePropertyLines {
192 my($IsotopeValuePairsRef) = @_;
193
194 return _GenerateCmpdGenericPropertyLines('Isotope', $IsotopeValuePairsRef);
195 }
196
197 # Generate radical property line property lines for CTAB block...
198 #
199 sub GenerateCmpdRadicalPropertyLines {
200 my($RadicalValuePairsRef) = @_;
201
202 return _GenerateCmpdGenericPropertyLines('Radical', $RadicalValuePairsRef);
203 }
204
205 # Generate atom alias property line property lines for CTAB block...
206 #
207 # Atom alias property line format:
208 #
209 # A aaa
210 # x...
211 #
212 # aaa: Atom number
213 # x: Atom alias in next line
214 #
215 sub GenerateCmpdAtomAliasPropertyLines {
216 my($PropertyValuePairsRef) = @_;
217 my($Index, $AtomNum, $AtomAlias, $Line, @PropertyLines);
218
219 @PropertyLines = ();
220
221 for ($Index = 0; $Index < $#{$PropertyValuePairsRef}; $Index += 2) {
222 $AtomNum = $PropertyValuePairsRef->[$Index];
223 $AtomAlias = $PropertyValuePairsRef->[$Index + 1];
224
225 $Line = "A " . sprintf "%3i", $AtomNum;
226
227 push @PropertyLines, $Line;
228 push @PropertyLines, $AtomAlias;
229 }
230
231 return @PropertyLines;
232 }
233
234 # Generate data header labels and values lines...
235 #
236 sub GenerateCmpdDataHeaderLabelsAndValuesLines {
237 my($DataHeaderLabelsRef, $DataHeaderLabelsAndValuesRef, $SortDataLabels) = @_;
238 my($DataLabel, $DataValue, @DataLabels, @DataLines);
239
240 if (!defined $SortDataLabels) {
241 $SortDataLabels = 0;
242 }
243
244 @DataLines = ();
245 @DataLabels = ();
246 if ($SortDataLabels) {
247 push @DataLabels, sort @{$DataHeaderLabelsRef};
248 }
249 else {
250 push @DataLabels, @{$DataHeaderLabelsRef};
251 }
252 for $DataLabel (@DataLabels) {
253 $DataValue = '';
254 if (exists $DataHeaderLabelsAndValuesRef->{$DataLabel}) {
255 $DataValue = $DataHeaderLabelsAndValuesRef->{$DataLabel};
256 }
257 push @DataLines, ("> <${DataLabel}>", "$DataValue", "");
258 }
259 return @DataLines;
260 }
261
262 # Parse data field header in SD file and return lists of all and common data field
263 # labels.
264 sub GetAllAndCommonCmpdDataHeaderLabels {
265 my($SDFileRef) = @_;
266 my($CmpdCount, $CmpdString, $Label, @CmpdLines, @DataFieldLabels, @CommonDataFieldLabels, %DataFieldLabelsMap);
267
268 $CmpdCount = 0;
269 @DataFieldLabels = ();
270 @CommonDataFieldLabels = ();
271 %DataFieldLabelsMap = ();
272
273 while ($CmpdString = ReadCmpdString($SDFileRef)) {
274 $CmpdCount++;
275 @CmpdLines = split "\n", $CmpdString;
276 # Process compound data header labels and figure out which ones are present for
277 # all the compounds...
278 if (@DataFieldLabels) {
279 my (@CmpdDataFieldLabels) = GetCmpdDataHeaderLabels(\@CmpdLines);
280 my(%CmpdDataFieldLabelsMap) = ();
281 # Setup a map for the current labels...
282 for $Label (@CmpdDataFieldLabels) {
283 $CmpdDataFieldLabelsMap{$Label} = "PresentInSome";
284 }
285 # Check the presence old labels for this compound; otherwise, mark 'em new...
286 for $Label (@DataFieldLabels) {
287 if (!$CmpdDataFieldLabelsMap{$Label}) {
288 $DataFieldLabelsMap{$Label} = "PresentInSome";
289 }
290 }
291 # Check the presence this compound in the old labels; otherwise, add 'em...
292 for $Label (@CmpdDataFieldLabels ) {
293 if (!$DataFieldLabelsMap{$Label}) {
294 # It's a new label...
295 push @DataFieldLabels, $Label;
296 $DataFieldLabelsMap{$Label} = "PresentInSome";
297 }
298 }
299 }
300 else {
301 # Get the initial label set and set up a map...
302 @DataFieldLabels = GetCmpdDataHeaderLabels(\@CmpdLines);
303 for $Label (@DataFieldLabels) {
304 $DataFieldLabelsMap{$Label} = "PresentInAll";
305 }
306 }
307 }
308 # Identify the common data field labels...
309 @CommonDataFieldLabels = ();
310 for $Label (@DataFieldLabels) {
311 if ($DataFieldLabelsMap{$Label} eq "PresentInAll") {
312 push @CommonDataFieldLabels, $Label;
313 }
314 }
315 return ($CmpdCount, \@DataFieldLabels, \@CommonDataFieldLabels);
316 }
317
318 # Parse all the data header labels and return 'em as an list...
319 #
320 # Format:
321 #
322 #> Data header line
323 #Data line(s)
324 #Blank line
325 #
326 # [Data Header] (one line) precedes each item of data, starts with a greater than (>) sign, and
327 # contains at least one of the following:
328 # The field name enclosed in angle brackets. For example: <melting.point>
329 # The field number, DTn , where n represents the number assigned to the field in a MACCS-II database
330 #
331 #Optional information for the data header includes:
332 # The compound’s external and internal registry numbers. External registry numbers must be enclosed in parentheses.
333 # Any combination of information
334 #
335 #The following are examples of valid data headers:
336 #> <MELTING.POINT>
337 #> 55 (MD-08974) <BOILING.POINT> DT12
338 #> DT12 55
339 #> (MD-0894) <BOILING.POINT> FROM ARCHIVES
340 #
341 #Notes: Sometimes last blank line is missing and can be just followed by $$$$
342 #
343 sub GetCmpdDataHeaderLabels {
344 my($CmpdLines) = @_;
345 my($CmpdLine, $Label, @Labels);
346
347 @Labels = ();
348 CMPDLINE: for $CmpdLine (@$CmpdLines) {
349 if ($CmpdLine !~ /^>/) {
350 next CMPDLINE;
351 }
352 # Does the line contains field name enclosed in angular brackets?
353 ($Label) = $CmpdLine =~ /<.*?>/g;
354 if (!defined($Label)) {
355 next CMPDLINE;
356 }
357 $Label =~ s/(<|>)//g;
358 push @Labels, $Label;
359 }
360 return (@Labels);
361 }
362
363 # Parse all the data header labels and values
364 sub GetCmpdDataHeaderLabelsAndValues {
365 my($CmpdLines) = @_;
366 my($CmpdLine, $CurrentLabel, $Label, $Value, $ValueCount, $ProcessingLabelData, @Values, %DataFields);
367
368 %DataFields = ();
369 $ProcessingLabelData = 0;
370 $ValueCount = 0;
371 CMPDLINE: for $CmpdLine (@$CmpdLines) {
372 if ($CmpdLine =~ /^\$\$\$\$/) {
373 last CMPDLINE;
374 }
375 if ($CmpdLine =~ /^>/) {
376 # Does the line contains field name enclosed in angular brackets?
377 ($Label) = $CmpdLine =~ /<.*?>/g;
378 if (defined $Label) {
379 $CurrentLabel = $Label;
380 $CurrentLabel =~ s/(<|>)//g;
381 $ProcessingLabelData = 0;
382 $ValueCount = 0;
383
384 if ($CurrentLabel) {
385 $ProcessingLabelData = 1;
386 $DataFields{$CurrentLabel} = '';
387 next CMPDLINE;
388 }
389 }
390 else {
391 if (!$ProcessingLabelData) {
392 # Data line containing no <label> as allowed by SDF format. Just ignore it...
393 next CMPDLINE;
394 }
395 }
396 }
397 if (!$ProcessingLabelData) {
398 next CMPDLINE;
399 }
400 if (!(defined($CmpdLine) && length($CmpdLine))) {
401 # Blank line terminates value for a label...
402 $CurrentLabel = '';
403 $ValueCount = 0;
404 $ProcessingLabelData = 0;
405 next CMPDLINE;
406 }
407 $ValueCount++;
408 $Value = $CmpdLine;
409
410 if ($ValueCount > 1) {
411 $DataFields{$CurrentLabel} .= "\n" . $Value;
412 }
413 else {
414 $DataFields{$CurrentLabel} = $Value;
415 }
416 }
417 return (%DataFields);
418 }
419
420 # Return an updated compoud string after removing data header label along with its
421 # value from the specified compound string...
422 #
423 sub RemoveCmpdDataHeaderLabelAndValue {
424 my($CmpdString, $DataHeaderLabel) = @_;
425 my($Line, $PorcessingDataHeaderLabel, @CmpdLines);
426
427 @CmpdLines = ();
428 $PorcessingDataHeaderLabel = 0;
429
430 CMPDLINE: for $Line (split "\n", $CmpdString) {
431 if ($Line =~ /^>/ && $Line =~ /<$DataHeaderLabel>/i) {
432 $PorcessingDataHeaderLabel = 1;
433 next CMPDLINE;
434 }
435
436 if ($PorcessingDataHeaderLabel) {
437 # Blank line indicates end of fingerprints data value...
438 if ($Line =~ /^\$\$\$\$/) {
439 push @CmpdLines, $Line;
440 $PorcessingDataHeaderLabel = 0;
441 }
442 elsif (!length($Line)) {
443 $PorcessingDataHeaderLabel = 0;
444 }
445 next CMPDLINE;
446 }
447
448 # Track compound lines without fingerprints data...
449 push @CmpdLines, $Line;
450 }
451
452 return join "\n", @CmpdLines;
453 }
454
455 #
456 # Using bond blocks, figure out the number of disconnected fragments and
457 # return their values along with the atom numbers in a string delimited by new
458 # line character.
459 #
460 sub GetCmpdFragments {
461 my($CmpdLines) = @_;
462 my($AtomCount, $BondCount, $FirstAtomNum, $SecondAtomNum, @AtomConnections, $BondType, $FragmentString, $FragmentCount, $LineIndex, $Index, $AtomNum, $NbrAtomNum, @ProcessedAtoms, $ProcessedAtomCount, $ProcessAtomNum, @ProcessingAtoms, @ConnectedAtoms, %Fragments, $FragmentNum, $AFragmentString);
463
464 # Setup the connection table for each atom...
465 @AtomConnections = ();
466 ($AtomCount, $BondCount) = ParseCmpdCountsLine(@$CmpdLines[3]);
467 for $AtomNum (1 .. $AtomCount) {
468 %{$AtomConnections[$AtomNum]} = ();
469 }
470 for ($LineIndex = 4 + $AtomCount; $LineIndex < (4 + $AtomCount + $BondCount); $LineIndex++) {
471 ($FirstAtomNum, $SecondAtomNum, $BondType) = ParseCmpdBondLine(@$CmpdLines[$LineIndex]);
472 if (!$AtomConnections[$FirstAtomNum]{$SecondAtomNum}) {
473 $AtomConnections[$FirstAtomNum]{$SecondAtomNum} = $BondType;
474 }
475 if (!$AtomConnections[$SecondAtomNum]{$FirstAtomNum}) {
476 $AtomConnections[$SecondAtomNum]{$FirstAtomNum} = $BondType;
477 }
478 }
479
480 #Get set to count fragments...
481 $ProcessedAtomCount = 0;
482 $FragmentNum = 0;
483 %Fragments = ();
484 @ProcessedAtoms = ();
485 for $AtomNum (1 .. $AtomCount) {
486 $ProcessedAtoms[$AtomNum] = 0;
487 }
488 while ($ProcessedAtomCount < $AtomCount) {
489 @ProcessingAtoms = ();
490 @ConnectedAtoms = ();
491 ATOMNUM: for $AtomNum (1 .. $AtomCount) {
492 if (!$ProcessedAtoms[$AtomNum]) {
493 $ProcessedAtomCount++;
494 $ProcessedAtoms[$AtomNum] = 1;
495 push @ProcessingAtoms, $AtomNum;
496 $FragmentNum++;
497 @{$Fragments{$FragmentNum} } = ();
498 push @{$Fragments{$FragmentNum} }, $AtomNum;
499 last ATOMNUM;
500 }
501 }
502
503 # Go over the neighbors and follow the connection trail while collecting the
504 # atoms numbers present in the connected fragment...
505 while (@ProcessingAtoms) {
506 for ($Index = 0; $Index < @ProcessingAtoms; $Index++) {
507 $ProcessAtomNum = $ProcessingAtoms[$Index];
508 for $NbrAtomNum (keys %{$AtomConnections[$ProcessAtomNum]}) {
509 if (!$ProcessedAtoms[$NbrAtomNum]) {
510 $ProcessedAtomCount++;
511 $ProcessedAtoms[$NbrAtomNum] = 1;
512 push @ConnectedAtoms, $NbrAtomNum;
513 push @{ $Fragments{$FragmentNum} }, $NbrAtomNum;
514 }
515 }
516 }
517 @ProcessingAtoms = ();
518 @ProcessingAtoms = @ConnectedAtoms;
519 @ConnectedAtoms = ();
520 }
521 }
522 $FragmentCount = $FragmentNum;
523 $FragmentString = "";
524
525 # Sort out the fragments by size...
526 for $FragmentNum (sort { @{$Fragments{$b}} <=> @{$Fragments{$a}} } keys %Fragments ) {
527 # Sort the atoms in a fragment by their numbers...
528 $AFragmentString = join " ", sort { $a <=> $b } @{ $Fragments{$FragmentNum} };
529 if ($FragmentString) {
530 $FragmentString .= "\n" . $AFragmentString;
531 }
532 else {
533 $FragmentString = $AFragmentString;
534 }
535 }
536 return ($FragmentCount, $FragmentString);
537 }
538
539 # Count number of lines present in between 4th and line containg "M END"
540 sub GetCtabLinesCount {
541 my($CmpdLines) = @_;
542 my($LineIndex, $CtabLinesCount);
543
544 $CtabLinesCount = 0;
545 LINE: for ($LineIndex = 4; $LineIndex < @$CmpdLines; $LineIndex++) {
546 #
547 # Any line after atom and bond data starting with anything other than space or
548 # a digit indicates end of Ctab atom/bond data block...
549 #
550 if (@$CmpdLines[$LineIndex] !~ /^[0-9 ]/) {
551 $CtabLinesCount = $LineIndex - 4;
552 last LINE;
553 }
554 }
555 return $CtabLinesCount;
556 }
557
558 # Using atom blocks, count the number of atoms which contain special element
559 # symbols not present in the periodic table.
560 sub GetUnknownAtoms {
561 my($CmpdLines) = @_;
562 my($UnknownAtomCount, $UnknownAtoms, $UnknownAtomLines, $LineIndex, $AtomCount, $AtomSymbol);
563
564 $UnknownAtomCount = 0;
565 $UnknownAtoms = "";
566 $UnknownAtomLines = "";
567 ($AtomCount) = ParseCmpdCountsLine(@$CmpdLines[3]);
568 for ($LineIndex = 4; $LineIndex < (4 + $AtomCount); $LineIndex++) {
569 ($AtomSymbol) = ParseCmpdAtomLine(@$CmpdLines[$LineIndex]);
570 if (!IsElement($AtomSymbol)) {
571 $UnknownAtomCount++;
572 $UnknownAtoms .= " $AtomSymbol";
573 if ($UnknownAtomLines) {
574 $UnknownAtomLines .= "\n" . @$CmpdLines[$LineIndex];
575 }
576 else {
577 $UnknownAtomLines = @$CmpdLines[$LineIndex];
578 }
579 }
580 }
581 return ($UnknownAtomCount, $UnknownAtoms, $UnknownAtomLines);
582 }
583
584 # Check z coordinates of all atoms to see whether any of them is non-zero
585 # which makes the compound geometry three dimensional...
586 #
587 sub IsCmpd3D {
588 my($CmpdLines) = @_;
589 my($LineIndex, $AtomCount, $AtomSymbol, $AtomX, $AtomY, $AtomZ);
590
591 ($AtomCount) = ParseCmpdCountsLine(@$CmpdLines[3]);
592 for ($LineIndex = 4; $LineIndex < (4 + $AtomCount); $LineIndex++) {
593 ($AtomSymbol, $AtomX, $AtomY, $AtomZ) = ParseCmpdAtomLine(@$CmpdLines[$LineIndex]);
594 if ($AtomZ != 0) {
595 return 1;
596 }
597 }
598 return 0;
599 }
600
601 # Check whether it's a 2D compound...
602 #
603 sub IsCmpd2D {
604 my($CmpdLines) = @_;
605
606 return IsCmpd3D($CmpdLines) ? 0 : 1;
607 }
608
609 # Using bond blocks, count the number of bond lines which contain atom numbers
610 # greater than atom count specified in compound count line...
611 #
612 sub GetInvalidAtomNumbers {
613 my($CmpdLines) = @_;
614 my($LineIndex, $AtomCount, $BondCount, $FirstAtomNum, $SecondAtomNum, $InvalidAtomNumbersCount, $InvalidAtomNumbers, $InvalidAtomNumberLines, $Line, $InvalidAtomPropertyLine, $ValuePairIndex, $AtomNum, $Value, @ValuePairs);
615
616 ($AtomCount, $BondCount) = ParseCmpdCountsLine(@$CmpdLines[3]);
617
618 $InvalidAtomNumbersCount = 0;
619 $InvalidAtomNumbers = "";
620 $InvalidAtomNumberLines = "";
621
622 # Go over bond block lines...
623 LINE: for ($LineIndex = 4 + $AtomCount; $LineIndex < (4 + $AtomCount + $BondCount); $LineIndex++) {
624 ($FirstAtomNum, $SecondAtomNum) = ParseCmpdBondLine(@$CmpdLines[$LineIndex]);
625 if ($FirstAtomNum <= $AtomCount && $SecondAtomNum <= $AtomCount) {
626 next LINE;
627 }
628 if ($FirstAtomNum > $AtomCount) {
629 $InvalidAtomNumbersCount++;
630 $InvalidAtomNumbers .= " $FirstAtomNum";
631 }
632 if ($SecondAtomNum > $AtomCount) {
633 $InvalidAtomNumbersCount++;
634 $InvalidAtomNumbers .= " $SecondAtomNum";
635 }
636 if ($InvalidAtomNumberLines) {
637 $InvalidAtomNumberLines .= "\n" . @$CmpdLines[$LineIndex];
638 }
639 else {
640 $InvalidAtomNumberLines = @$CmpdLines[$LineIndex];
641 }
642 }
643 # Go over property lines before M END...
644 #
645 LINE: for ($LineIndex = (4 + $AtomCount + $BondCount); $LineIndex < @$CmpdLines; $LineIndex++) {
646 $Line = @$CmpdLines[$LineIndex];
647 @ValuePairs = ();
648 if ($Line =~ /^M END/i) {
649 last LINE;
650 }
651 @ValuePairs = ();
652 if ($Line =~ /^M CHG/i) {
653 @ValuePairs = ParseCmpdChargePropertyLine($Line);
654 }
655 elsif ($Line =~ /^M RAD/i) {
656 @ValuePairs = ParseCmpdRadicalPropertyLine($Line);
657 }
658 elsif ($Line =~ /^M ISO/i) {
659 @ValuePairs = ParseCmpdIsotopePropertyLine($Line);
660 }
661 elsif ($Line =~ /^A /i) {
662 my($NextLine);
663 $LineIndex++;
664 $NextLine = @$CmpdLines[$LineIndex];
665 @ValuePairs = ParseCmpdAtomAliasPropertyLine($Line, $NextLine);
666 }
667 else {
668 next LINE;
669 }
670
671 $InvalidAtomPropertyLine = 0;
672 for ($ValuePairIndex = 0; $ValuePairIndex < $#ValuePairs; $ValuePairIndex += 2) {
673 $AtomNum = $ValuePairs[$ValuePairIndex]; $Value = $ValuePairs[$ValuePairIndex + 1];
674 if ($AtomNum > $AtomCount) {
675 $InvalidAtomPropertyLine = 1;
676 $InvalidAtomNumbersCount++;
677 $InvalidAtomNumbers .= " $AtomNum";
678 }
679 }
680 if ($InvalidAtomPropertyLine) {
681 if ($InvalidAtomNumberLines) {
682 $InvalidAtomNumberLines .= "\n" . $Line;
683 }
684 else {
685 $InvalidAtomNumberLines = $Line;
686 }
687 }
688 }
689
690 return ($InvalidAtomNumbersCount, $InvalidAtomNumbers, $InvalidAtomNumberLines);
691 }
692
693 # Ctab lines: Atom block
694 #
695 # Format: xxxxx.xxxxyyyyy.yyyyzzzzz.zzzz aaaddcccssshhhbbbvvvHHHrrriiimmmnnneee
696 # A10 A10 A10 xA3 A2A3 A3 A3 A3 A3 A3 A3 A3 A3 A3 A3
697 # x,y,z: Atom coordinates
698 # aaa: Atom symbol. Entry in periodic table or L for atom list, A, Q, * for unspecified
699 # atom, and LP for lone pair, or R# for Rgroup label
700 # dd: Mass difference. -3, -2, -1, 0, 1, 2, 3, 4 (0 for value beyond these limits)
701 # ccc: Charge. 0 = uncharged or value other than these, 1 = +3, 2 = +2, 3 = +1,
702 # 4 = doublet radical, 5 = -1, 6 = -2, 7 = -3
703 # sss: Atom stereo parity. 0 = not stereo, 1 = odd, 2 = even, 3 = either or unmarked stereo center
704 # hhh: Hydrogen count + 1. 1 = H0, 2 = H1, 3 = H2, 4 = H3, 5 = H4
705 # bbb: Stereo care box. 0 = ignore stereo configuration of this double bond atom, 1 = stereo
706 # configuration of double bond atom must match
707 # vvv: Valence. 0 = no marking (default)(1 to 14) = (1 to 14) 15 = zero valence
708 # HHH: H0 designator. 0 = not specified, 1 = no H atoms allowed (redundant due to hhh)
709 # rrr: Not used
710 # iii: Not used
711 # mmm: Atom-atom mapping number. 1 - number of atoms
712 # nnn: Inversion/retention flag. 0 = property not applied, 1 = configuration is inverted,
713 # 2 = configuration is retained.
714 # eee: Exact change flag. 0 = property not applied, 1 = change on atom must be
715 # exactly as shown
716 #
717 # Notes:
718 # . StereoParity: 1 - ClockwiseStereo, 2 - AntiClockwiseStereo; 3 - Either; 0 - none. These
719 # values determine chirailty around the chiral center; a non zero value indicates atom
720 # has been marked as chiral center.
721 #
722 sub ParseCmpdAtomLine {
723 my($Line) = @_;
724 my ($LineIndex, $AtomX, $AtomY, $AtomZ, $AtomSymbol, $MassDifference, $Charge, $StereoParity);
725
726 ($AtomX, $AtomY, $AtomZ, $AtomSymbol, $MassDifference, $Charge, $StereoParity) = ('') x 7;
727 if (length($Line) > 31) {
728 ($AtomX, $AtomY, $AtomZ, $AtomSymbol, $MassDifference, $Charge, $StereoParity) = unpack("A10A10A10xA3A2A3A3", $Line);
729 }
730 else {
731 ($AtomX, $AtomY, $AtomZ, $AtomSymbol) = unpack("A10A10A10", $Line);
732 }
733 return ($AtomSymbol, $AtomX, $AtomY, $AtomZ, $MassDifference, $Charge, $StereoParity);
734 }
735
736 # Map MDL charge value used in SD and MOL files to internal charge used by MayaChemTools.
737 #
738 sub MDLChargeToInternalCharge {
739 my($MDLCharge) = @_;
740 my($InternalCharge);
741
742 CHARGE: {
743 if ($MDLCharge == 0) { $InternalCharge = 0; last CHARGE;}
744 if ($MDLCharge == 1) { $InternalCharge = 3; last CHARGE;}
745 if ($MDLCharge == 2) { $InternalCharge = 2; last CHARGE;}
746 if ($MDLCharge == 3) { $InternalCharge = 1; last CHARGE;}
747 if ($MDLCharge == 5) { $InternalCharge = -1; last CHARGE;}
748 if ($MDLCharge == 6) { $InternalCharge = -2; last CHARGE;}
749 if ($MDLCharge == 7) { $InternalCharge = -3; last CHARGE;}
750 # All other MDL charge values, including 4 corresponding to "doublet radical",
751 # are assigned internal value of 0.
752 $InternalCharge = 0;
753 if ($MDLCharge != 4) {
754 carp "Warning: MDLChargeToInternalCharge: MDL charge value, $MDLCharge, is not supported: An internal charge value, 0, has been assigned...";
755 }
756 }
757 return $InternalCharge;
758 }
759
760 # Map internal charge used by MayaChemTools to MDL charge value used in SD and MOL files.
761 #
762 sub InternalChargeToMDLCharge {
763 my($InternalCharge) = @_;
764 my($MDLCharge);
765
766 CHARGE: {
767 if ($InternalCharge == 3) { $MDLCharge = 1; last CHARGE;}
768 if ($InternalCharge == 2) { $MDLCharge = 2; last CHARGE;}
769 if ($InternalCharge == 1) { $MDLCharge = 3; last CHARGE;}
770 if ($InternalCharge == -1) { $MDLCharge = 5; last CHARGE;}
771 if ($InternalCharge == -2) { $MDLCharge = 6; last CHARGE;}
772 if ($InternalCharge == -3) { $MDLCharge = 7; last CHARGE;}
773 # All other MDL charge values, including 4 corresponding to "doublet radical",
774 # are assigned internal value of 0.
775 $MDLCharge = 0;
776 }
777 return $MDLCharge;
778 }
779
780 # Ctab lines: Bond block
781 #
782 # Format: 111222tttsssxxxrrrccc
783 #
784 # 111: First atom number.
785 # 222: Second atom number.
786 # ttt: Bond type. 1 = Single, 2 = Double, 3 = Triple, 4 = Aromatic, 5 = Single or Double,
787 # 6 = Single or Aromatic, 7 = Double or Aromatic, 8 = Any
788 # sss: Bond stereo. Single bonds: 0 = not stereo, 1 = Up, 4 = Either, 6 = Down,
789 # Double bonds: 0 = Use x-, y-, z-coords from atom block to determine cis or trans,
790 # 3 = Cis or trans (either) double bond
791 # xxx: Not used
792 # rrr: Bond topology. 0 = Either, 1 = Ring, 2 = Chain
793 # ccc: Reacting center status. 0 = unmarked, 1 = a center, -1 = not a center,
794 # Additional: 2 = no change,4 = bond made/broken, 8 = bond order changes 12 = 4+8
795 # (both made/broken and changes); 5 = (4 + 1), 9 = (8 + 1), and 13 = (12 + 1) are also possible
796 #
797 sub ParseCmpdBondLine {
798 my($Line) = @_;
799 my($FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo);
800
801 ($FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo) = map {s/ //g; $_} unpack("A3A3A3A3", $Line);
802 return ($FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo);
803 }
804
805 # Map MDL bond type value used in SD and MOL files to internal bond order and bond types
806 # values used by MayaChemTools...
807 #
808 sub MDLBondTypeToInternalBondOrder {
809 my($MDLBondType) = @_;
810 my($InternalBondOrder, $InternalBondType);
811
812 $InternalBondType = '';
813
814 BONDTYPE: {
815 if ($MDLBondType == 1) { $InternalBondOrder = 1; $InternalBondType = 'Single'; last BONDTYPE;}
816 if ($MDLBondType == 2) { $InternalBondOrder = 2; $InternalBondType = 'Double'; last BONDTYPE;}
817 if ($MDLBondType == 3) { $InternalBondOrder = 3; $InternalBondType = 'Triple'; last BONDTYPE;}
818 if ($MDLBondType == 4) { $InternalBondOrder = 1.5; $InternalBondType = 'Aromatic'; last BONDTYPE;} # Aromatic
819 if ($MDLBondType == 5) { $InternalBondOrder = 1; $InternalBondType = 'SingleOrDouble'; last BONDTYPE;} # Aromatic
820 if ($MDLBondType == 6) { $InternalBondOrder = 1; $InternalBondType = 'SingleOrAromatic'; last BONDTYPE;} # Aromatic
821 if ($MDLBondType == 7) { $InternalBondOrder = 2; $InternalBondType = 'DoubleOrAromatic'; last BONDTYPE;} # Aromatic
822 if ($MDLBondType == 8) { $InternalBondOrder = 1; $InternalBondType = 'Any'; last BONDTYPE;} # Aromatic
823 #
824 # Although MDL aromatic bond values are used for query only and explicit Kekule bond order
825 # values must be assigned, internal value of 1.5 is allowed to indicate aromatic bond orders.
826 #
827 # All other MDL bond type values - 5 = Single or Double, 6 = Single or Aromatic, 7 = Double or Aromatic,
828 # 8 = Any - are also assigned appropriate internal value of 1: These are meant to be used for
829 # structure queries by MDL products.
830 #
831 $InternalBondOrder = 1;
832 $InternalBondType = 'Single';
833
834 carp "Warning: MDLBondTypeToInternalBondOrder: MDL bond type value, $MDLBondType, is not supported: An internal bond order value, 0, has been assigned...";
835 }
836 return ($InternalBondOrder, $InternalBondType);
837 }
838
839 # Map internal bond order and bond type values used by MayaChemTools to MDL bond type value used
840 # in SD and MOL files...
841 #
842 sub InternalBondOrderToMDLBondType {
843 my($InternalBondOrder, $InternalBondType) = @_;
844 my($MDLBondType);
845
846 BONDTYPE: {
847 if ($InternalBondOrder == 1) {
848 if ($InternalBondType =~ /^SingleOrDouble$/i) {
849 $MDLBondType = 5;
850 }
851 elsif ($InternalBondType =~ /^SingleOrAromatic$/i) {
852 $MDLBondType = 6;
853 }
854 elsif ($InternalBondType =~ /^Any$/i) {
855 $MDLBondType = 8;
856 }
857 else {
858 $MDLBondType = 1;
859 }
860 $MDLBondType = 1;
861 last BONDTYPE;
862 }
863 if ($InternalBondOrder == 2) {
864 if ($InternalBondType =~ /^DoubleOrAromatic$/i) {
865 $MDLBondType = 7;
866 }
867 else {
868 $MDLBondType = 2;
869 }
870 last BONDTYPE;
871 }
872 if ($InternalBondOrder == 3) { $MDLBondType = 3; last BONDTYPE;}
873 if ($InternalBondOrder == 1.5) { $MDLBondType = 4; last BONDTYPE;}
874 if ($InternalBondType =~ /^Any$/i) { $MDLBondType = 8; last BONDTYPE;}
875
876 $MDLBondType = 1;
877
878 carp "Warning: InternalBondOrderToMDLBondType: Internal bond order and type values, $InternalBondOrder and $InternalBondType, don't match any valid MDL bond type: MDL bond type value, 1, has been assigned...";
879 }
880 return $MDLBondType;
881 }
882
883 # Third line: Comments - A blank line is also allowed.
884 sub ParseCmpdCommentsLine {
885 my($Line) = @_;
886 my($Comments);
887
888 $Comments = unpack("A80", $Line);
889
890 return ($Comments);
891 }
892
893 # Map MDL bond stereo value used in SD and MOL files to internal bond stereochemistry values used by MayaChemTools...
894 #
895 sub MDLBondStereoToInternalBondStereochemistry {
896 my($MDLBondStereo) = @_;
897 my($InternalBondStereo);
898
899 $InternalBondStereo = '';
900
901 BONDSTEREO: {
902 if ($MDLBondStereo == 1) { $InternalBondStereo = 'Up'; last BONDSTEREO;}
903 if ($MDLBondStereo == 4) { $InternalBondStereo = 'UpOrDown'; last BONDSTEREO;}
904 if ($MDLBondStereo == 6) { $InternalBondStereo = 'Down'; last BONDSTEREO;}
905 if ($MDLBondStereo == 3) { $InternalBondStereo = 'CisOrTrans'; last BONDSTEREO;}
906 if ($MDLBondStereo == 0) { $InternalBondStereo = 'None'; last BONDSTEREO;}
907
908 $InternalBondStereo = '';
909 carp "Warning: MDLBondStereoToInternalBondType: MDL bond stereo value, $MDLBondStereo, is not supported: It has been ignored and bond order would be used to determine bond type...";
910 }
911 return $InternalBondStereo;
912 }
913
914 # Map internal bond stereochemistry values used by MayaChemTools to MDL bond stereo value used in SD and MOL files...
915 #
916 sub InternalBondStereochemistryToMDLBondStereo {
917 my($InternalBondStereo) = @_;
918 my($MDLBondStereo);
919
920 $MDLBondStereo = 0;
921
922 BONDSTEREO: {
923 if ($InternalBondStereo =~ /^Up$/i) { $MDLBondStereo = 1; last BONDSTEREO;}
924 if ($InternalBondStereo =~ /^UpOrDown$/i) { $MDLBondStereo = 4; last BONDSTEREO;}
925 if ($InternalBondStereo =~ /^Down$/) { $MDLBondStereo = 6; last BONDSTEREO;}
926 if ($InternalBondStereo =~ /^CisOrTrans$/) { $MDLBondStereo = 3; last BONDSTEREO;}
927
928 $MDLBondStereo = 0;
929 }
930 return $MDLBondStereo;
931 }
932
933 # Fourth line: Counts
934 #
935 # Format: aaabbblllfffcccsssxxxrrrpppiiimmmvvvvvv
936 #
937 # aaa: number of atoms; bbb: number of bonds; lll: number of atom lists; fff: (obsolete)
938 # ccc: chiral flag: 0=not chiral, 1=chiral; sss: number of stext entries; xxx,rrr,ppp,iii:
939 # (obsolete); mmm: number of lines of additional properties, including the M END line, No
940 # longer supported, default is set to 999; vvvvvv: version
941
942 sub ParseCmpdCountsLine {
943 my($Line) = @_;
944 my($AtomCount, $BondCount, $ChiralFlag, $PropertyCount, $Version);
945
946 if (length($Line) >= 39) {
947 ($AtomCount, $BondCount, $ChiralFlag, $PropertyCount, $Version) = unpack("A3A3x3x3A3x3x3x3x3x3A3A6", $Line);
948 }
949 elsif (length($Line) >= 15) {
950 ($PropertyCount, $Version) = ("999", "v2000");
951 ($AtomCount, $BondCount, $ChiralFlag) = unpack("A3A3x3x3A3", $Line);
952 }
953 else {
954 ($ChiralFlag, $PropertyCount, $Version) = ("0", "999", "v2000");
955 ($AtomCount, $BondCount) = unpack("A3A3", $Line);
956 }
957
958 if ($Version =~ /V3000/i) {
959 # Current version of MayaChemTools modules and classes for processing MDL MOL and SD don't support
960 # V3000. So instead of relying on callers, just exit with an error to disable any processing of V3000
961 # format.
962 croak "Error: SDFileUtil::ParseCmpdCountsLine: The Extended Connection Table (V3000) format in MDL MOL and SD files is not supported by the current release of MayaChemTools...";
963 }
964
965 return ($AtomCount, $BondCount, $ChiralFlag, $PropertyCount, $Version);
966 }
967
968 # Second line: Misc info
969 #
970 # Format: IIPPPPPPPPMMDDYYHHmmddSSssssssssssEEEEEEEEEEEERRRRRR
971 # A2A8 A10 A2I2A10 A12 A6
972 # User's first and last initials (I), program name (P), date/time (M/D/Y,H:m),
973 # dimensional codes - 2D or 3D (d),scaling factors (S, s), energy (E) if modeling program input,
974 # internal registry number (R) if input through MDL form. A blank line is also allowed.
975 sub ParseCmpdMiscInfoLine {
976 my($Line) = @_;
977 my($UserInitial, $ProgramName, $Date, $Code, $ScalingFactor1, $ScalingFactor2, $Energy, $RegistryNum);
978
979 ($UserInitial, $ProgramName, $Date, $Code, $ScalingFactor1, $ScalingFactor2, $Energy, $RegistryNum) = unpack("A2A8A10A2A2A10A12A6", $Line);
980 return ($UserInitial, $ProgramName, $Date, $Code, $ScalingFactor1, $ScalingFactor2, $Energy, $RegistryNum);
981 }
982
983 # First line: Molecule name. This line is unformatted, but like all other lines in a
984 # molfile may not extend beyond column 80. A blank line is also allowed.
985 sub ParseCmpdMolNameLine {
986 my($Line) = @_;
987 my($MolName);
988
989 $MolName = unpack("A80", $Line);
990
991 return ($MolName);
992 }
993
994 # Parse atom alias property line in CTAB generic properties block.
995 #
996 # Atom alias property line format:
997 #
998 # A aaa
999 # x...
1000 #
1001 # aaa: Atom number
1002 # x: Atom alias in next line
1003 #
1004 sub ParseCmpdAtomAliasPropertyLine {
1005 my($Line, $NextLine) = @_;
1006 my($Label, $AtomNumber, $AtomAlias);
1007
1008 ($Label, $AtomNumber) = split(' ', $Line);
1009 $AtomAlias = $NextLine;
1010
1011 if (!$AtomAlias) {
1012 carp "Warning: _ParseCmpdAtomAliasPropertyLine: No atom alias value specified on the line following atom alias property line...";
1013 }
1014
1015 return ($AtomNumber, $AtomAlias);
1016 }
1017
1018 # Parse charge property line in CTAB generic properties block.
1019 #
1020 # Charge property line format:
1021 #
1022 # M CHGnn8 aaa vvv ...
1023 #
1024 # nn8: Number of value pairs. Maximum of 8 pairs allowed.
1025 # aaa: Atom number
1026 # vvv: -15 to +15. Default of 0 = uncharged atom. When present, this property supersedes
1027 # all charge and radical values in the atom block, forcing a 0 charge on all atoms not
1028 # listed in an M CHG or M RAD line.
1029 #
1030 sub ParseCmpdChargePropertyLine {
1031 my($Line) = @_;
1032
1033 return _ParseCmpdGenericPropertyLine('Charge', $Line);
1034 }
1035
1036
1037 # Parse isotope property line in CTAB generic properties block.
1038 #
1039 # Isoptope property line format:
1040 #
1041 # M ISOnn8 aaa vvv ...
1042 #
1043 # nn8: Number of value paris. Maximum of 8 pairs allowed.
1044 # aaa: Atom number
1045 # vvv: Absolute mass of the atom isotope as a positive integer. When present, this property
1046 # supersedes all isotope values in the atom block. Default (no entry) means natural
1047 # abundance. The difference between this absolute mass value and the natural
1048 # abundance value specified in the PTABLE.DAT file must be within the range of -18
1049 # to +12
1050 #
1051 # Notes:
1052 # . Values correspond to mass numbers...
1053 #
1054 sub ParseCmpdIsotopePropertyLine {
1055 my($Line) = @_;
1056
1057 return _ParseCmpdGenericPropertyLine('Isotope', $Line);
1058 }
1059
1060 # Parse radical property line in CTAB generic properties block.
1061 #
1062 # Radical property line format:
1063 #
1064 # M RADnn8 aaa vvv ...
1065 #
1066 # nn8: Number of value paris. Maximum of 8 pairs allowed.
1067 # aaa: Atom number
1068 # vvv: Default of 0 = no radical, 1 = singlet, 2 = doublet, 3 = triplet . When
1069 # present, this property supersedes all charge and radical values in the atom block,
1070 # forcing a 0 (zero) charge and radical on all atoms not listed in an M CHG or
1071 # M RAD line.
1072 #
1073 sub ParseCmpdRadicalPropertyLine {
1074 my($Line) = @_;
1075
1076 return _ParseCmpdGenericPropertyLine('Radical', $Line);
1077 }
1078
1079 # Map MDL radical stereo value used in SD and MOL files to internal spin multiplicity values used by MayaChemTools...
1080 #
1081 sub MDLRadicalToInternalSpinMultiplicity {
1082 my($MDLRadical) = @_;
1083 my($InternalSpinMultiplicity);
1084
1085 $InternalSpinMultiplicity = '';
1086
1087 SPINMULTIPLICITY: {
1088 if ($MDLRadical == 0) { $InternalSpinMultiplicity = 0; last SPINMULTIPLICITY;}
1089 if ($MDLRadical == 1) { $InternalSpinMultiplicity = 1; last SPINMULTIPLICITY;}
1090 if ($MDLRadical == 2) { $InternalSpinMultiplicity = 2; last SPINMULTIPLICITY;}
1091 if ($MDLRadical == 3) { $InternalSpinMultiplicity = 3; last SPINMULTIPLICITY;}
1092 $InternalSpinMultiplicity = '';
1093 carp "Warning: MDLRadicalToInternalSpinMultiplicity: MDL radical value, $MDLRadical, specifed on line M RAD is not supported...";
1094 }
1095 return $InternalSpinMultiplicity;
1096 }
1097
1098 # Map internal spin multiplicity values used by MayaChemTools to MDL radical stereo value used in SD and MOL files...
1099 #
1100 sub InternalSpinMultiplicityToMDLRadical {
1101 my($InternalSpinMultiplicity) = @_;
1102 my($MDLRadical);
1103
1104 $MDLRadical = 0;
1105
1106 SPINMULTIPLICITY: {
1107 if ($InternalSpinMultiplicity == 1) { $MDLRadical = 1; last SPINMULTIPLICITY;}
1108 if ($InternalSpinMultiplicity == 2) { $MDLRadical = 2; last SPINMULTIPLICITY;}
1109 if ($InternalSpinMultiplicity == 3) { $MDLRadical = 3; last SPINMULTIPLICITY;}
1110 $MDLRadical = 0;
1111 }
1112 return $MDLRadical;
1113 }
1114
1115 # Process generic CTAB property line...
1116 sub _ParseCmpdGenericPropertyLine {
1117 my($PropertyName, $Line) = @_;
1118
1119 my($Label, $PropertyLabel, $ValuesCount, $ValuePairsCount, @ValuePairs);
1120
1121 @ValuePairs = ();
1122 ($Label, $PropertyLabel, $ValuesCount, @ValuePairs) = split(' ', $Line);
1123 $ValuePairsCount = (scalar @ValuePairs)/2;
1124 if ($ValuesCount != $ValuePairsCount) {
1125 carp "Warning: _ParseCmpdGenericPropertyLine: Number of atom number and $PropertyName value paris specified on $Label $PropertyLabel property line, $ValuePairsCount, does not match expected value of $ValuesCount...";
1126 }
1127
1128 return (@ValuePairs);
1129 }
1130
1131 # Generic CTAB property lines for charge, istope and radical properties...
1132 #
1133 sub _GenerateCmpdGenericPropertyLines {
1134 my($PropertyName, $PropertyValuePairsRef) = @_;
1135 my($Index, $PropertyLabel, $Line, $PropertyCount, $AtomNum, $PropertyValue, @PropertyLines);
1136
1137 @PropertyLines = ();
1138 NAME: {
1139 if ($PropertyName =~ /^Charge$/i) { $PropertyLabel = "M CHG"; last NAME; }
1140 if ($PropertyName =~ /^Isotope$/i) { $PropertyLabel = "M ISO"; last NAME; }
1141 if ($PropertyName =~ /^Radical$/i) { $PropertyLabel = "M RAD"; last NAME; }
1142 carp "Warning: _GenerateCmpdGenericPropertyLines: Unknown property name, $PropertyName, specified...";
1143 return @PropertyLines;
1144 }
1145
1146 # A maximum of 8 property pair values allowed per line...
1147 $PropertyCount = 0;
1148 $Line = '';
1149 for ($Index = 0; $Index < $#{$PropertyValuePairsRef}; $Index += 2) {
1150 if ($PropertyCount > 8) {
1151 # Setup property line...
1152 $Line = "${PropertyLabel} 8${Line}";
1153 push @PropertyLines, $Line;
1154
1155 $PropertyCount = 0;
1156 $Line = '';
1157 }
1158 $PropertyCount++;
1159 $AtomNum = $PropertyValuePairsRef->[$Index];
1160 $PropertyValue = $PropertyValuePairsRef->[$Index + 1];
1161 $Line .= sprintf " %3i %3i", $AtomNum, $PropertyValue;
1162 }
1163 if ($Line) {
1164 $Line = "${PropertyLabel} ${PropertyCount}${Line}";
1165 push @PropertyLines, $Line;
1166 }
1167 return @PropertyLines;
1168 }
1169
1170 #
1171 # Read compound data into a string and return its value
1172 sub ReadCmpdString {
1173 my($SDFileRef) = @_;
1174 my($CmpdString);
1175
1176 $CmpdString = "";
1177 LINE: while (defined($_ = <$SDFileRef>)) {
1178 # Change Windows and Mac new line char to UNIX...
1179 s/(\r\n)|(\r)/\n/g;
1180
1181 if (/^\$\$\$\$/) {
1182 # Take out any new line char at the end by explicitly removing it instead of using
1183 # chomp, which might not always work correctly on files generated on a system
1184 # with a value of input line separator different from the current system...
1185 s/\n$//g;
1186
1187 # Doesn't hurt to chomp...
1188 chomp;
1189
1190 $CmpdString .= $_;
1191 last LINE;
1192 }
1193 else {
1194 $CmpdString .= $_;
1195 }
1196 }
1197 return $CmpdString;
1198 }
1199
1200 # Find out the number of fragements in the compounds. And for the compound with
1201 # more than one fragment, remove all the others besides the largest one.
1202 sub WashCmpd {
1203 my($CmpdLines) = @_;
1204 my($WashedCmpdString, $FragmentCount, $Fragments);
1205
1206 $WashedCmpdString = "";
1207 ($FragmentCount, $Fragments) = GetCmpdFragments($CmpdLines);
1208 if ($FragmentCount > 1) {
1209 # Go over the compound data for the largest fragment including property
1210 # data...
1211 my (@AllFragments, @LargestFragment, %LargestFragmentAtoms, @WashedCmpdLines, $Index, $LineIndex, $AtomCount, $BondCount, $NewAtomCount, $NewBondCount, $FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo, $FirstNewAtomNum, $SecondNewAtomNum, $AtomNum, $ChiralFlag, $BondLine, $MENDLineIndex, $Line, $Value, @ValuePairs, @NewValuePairs, $ValuePairIndex, $NewAtomNum, @NewPropertyLines);
1212
1213 @AllFragments = (); @LargestFragment = ();
1214 %LargestFragmentAtoms = ();
1215 @AllFragments = split "\n", $Fragments;
1216 @LargestFragment = split " ", $AllFragments[0];
1217 for $Index (0 .. $#LargestFragment) {
1218 # Map old atom numbers to new atom numbers as the fragment atom numbers are sorted
1219 # from lowest to highest old atom numbers...
1220 $LargestFragmentAtoms{$LargestFragment[$Index]} = $Index + 1;
1221 }
1222 @WashedCmpdLines = ();
1223 push @WashedCmpdLines, @$CmpdLines[0], @$CmpdLines[1], @$CmpdLines[2], @$CmpdLines[3];
1224 ($AtomCount, $BondCount, $ChiralFlag) = ParseCmpdCountsLine(@$CmpdLines[3]);
1225 $NewAtomCount = @LargestFragment;
1226 $NewBondCount = 0;
1227 $AtomNum = 0;
1228 # Retrieve the largest fragment atom lines...
1229 for ($LineIndex = 4; $LineIndex < (4 + $AtomCount); $LineIndex++) {
1230 $AtomNum++;
1231 if ($LargestFragmentAtoms{$AtomNum}) {
1232 push @WashedCmpdLines, @$CmpdLines[$LineIndex];
1233 }
1234 }
1235 # Retrieve the largest fragment bond lines...
1236 for ($LineIndex = 4 + $AtomCount; $LineIndex < (4 + $AtomCount + $BondCount); $LineIndex++) {
1237 ($FirstAtomNum, $SecondAtomNum, $BondType, $BondStereo) = ParseCmpdBondLine(@$CmpdLines[$LineIndex]);
1238 if ($LargestFragmentAtoms{$FirstAtomNum} && $LargestFragmentAtoms{$SecondAtomNum}) {
1239 $NewBondCount++;
1240 # Set up bond line with new atom number mapping...
1241 $FirstNewAtomNum = $LargestFragmentAtoms{$FirstAtomNum};
1242 $SecondNewAtomNum = $LargestFragmentAtoms{$SecondAtomNum};
1243 $BondLine = GenerateCmpdBondLine($FirstNewAtomNum, $SecondNewAtomNum, $BondType, $BondStereo);
1244 push @WashedCmpdLines, $BondLine;
1245 }
1246 }
1247 # Get property lines for CHG, ISO and RAD label and map the old atom numbers to new
1248 # atom numners; Others, property lines before M END line are skipped as atom numbers for
1249 # other properties might not valid anymore...
1250 #
1251 $MENDLineIndex = $LineIndex;
1252 LINE: for ($LineIndex = (4 + $AtomCount + $BondCount); $LineIndex < @$CmpdLines; $LineIndex++) {
1253 $Line = @$CmpdLines[$LineIndex];
1254 if ($Line =~ /^M END/i) {
1255 push @WashedCmpdLines, "M END";
1256 $MENDLineIndex = $LineIndex;
1257 last LINE;
1258 }
1259
1260 @ValuePairs = ();
1261 if ($Line =~ /^M CHG/i) {
1262 @ValuePairs = ParseCmpdChargePropertyLine($Line);
1263 }
1264 elsif ($Line =~ /^M RAD/i) {
1265 @ValuePairs = ParseCmpdRadicalPropertyLine($Line);
1266 }
1267 elsif ($Line =~ /^M ISO/i) {
1268 @ValuePairs = ParseCmpdIsotopePropertyLine($Line);
1269 }
1270 elsif ($Line =~ /^A /i) {
1271 my($NextLine);
1272 $LineIndex++;
1273 $NextLine = @$CmpdLines[$LineIndex];
1274 @ValuePairs = ParseCmpdAtomAliasPropertyLine($Line, $NextLine);
1275 }
1276 else {
1277 next LINE;
1278 }
1279
1280 if (!@ValuePairs) {
1281 next LINE;
1282 }
1283
1284 # Collect values for valid atom numbers with mapping to new atom numbers...
1285 @NewValuePairs = ();
1286 VALUEINDEX: for ($ValuePairIndex = 0; $ValuePairIndex < $#ValuePairs; $ValuePairIndex += 2) {
1287 $AtomNum = $ValuePairs[$ValuePairIndex]; $Value = $ValuePairs[$ValuePairIndex + 1];
1288 if (!exists $LargestFragmentAtoms{$AtomNum}) {
1289 next VALUEINDEX;
1290 }
1291 $NewAtomNum = $LargestFragmentAtoms{$AtomNum};
1292 push @NewValuePairs, ($NewAtomNum, $Value)
1293 }
1294 if (!@NewValuePairs) {
1295 next LINE;
1296 }
1297 @NewPropertyLines = ();
1298 if ($Line =~ /^M CHG/i) {
1299 @NewPropertyLines = GenerateCmpdChargePropertyLines(\@NewValuePairs);
1300 }
1301 elsif ($Line =~ /^M RAD/i) {
1302 @NewPropertyLines = GenerateCmpdRadicalPropertyLines(\@NewValuePairs);
1303 }
1304 elsif ($Line =~ /^M ISO/i) {
1305 @NewPropertyLines = GenerateCmpdIsotopePropertyLines(\@NewValuePairs);
1306 }
1307 elsif ($Line =~ /^A /i) {
1308 @NewPropertyLines = GenerateCmpdAtomAliasPropertyLines(\@NewValuePairs);
1309 }
1310 push @WashedCmpdLines, @NewPropertyLines;
1311 }
1312
1313 # Retrieve rest of the data label and value property data...
1314 for ($LineIndex = (1 + $MENDLineIndex); $LineIndex < @$CmpdLines; $LineIndex++) {
1315 push @WashedCmpdLines, @$CmpdLines[$LineIndex];
1316 }
1317 # Update atom and bond count line...
1318 $WashedCmpdLines[3] = GenerateCmpdCountsLine($NewAtomCount, $NewBondCount, $ChiralFlag);
1319
1320 $WashedCmpdString = join "\n", @WashedCmpdLines;
1321 }
1322 return ($FragmentCount, $Fragments, $WashedCmpdString);
1323 }
1324
1325 1;
1326
1327 __END__
1328
1329 =head1 NAME
1330
1331 SDFileUtil
1332
1333 =head1 SYNOPSIS
1334
1335 use SDFileUtil ;
1336
1337 use SDFileUtil qw(:all);
1338
1339 =head1 DESCRIPTION
1340
1341 B<SDFileUtil> module provides the following functions:
1342
1343 GenerateCmpdAtomAliasPropertyLines, GenerateCmpdAtomLine, GenerateCmpdBondLine,
1344 GenerateCmpdChargePropertyLines, GenerateCmpdCommentsLine, GenerateCmpdCountsLine,
1345 GenerateCmpdDataHeaderLabelsAndValuesLines, GenerateCmpdIsotopePropertyLines,
1346 GenerateCmpdMiscInfoLine, GenerateCmpdMolNameLine,
1347 GenerateCmpdRadicalPropertyLines, GenerateEmptyCtabBlockLines,
1348 GenerateMiscLineDateStamp, GetAllAndCommonCmpdDataHeaderLabels,
1349 GetCmpdDataHeaderLabels, GetCmpdDataHeaderLabelsAndValues, GetCmpdFragments,
1350 GetCtabLinesCount, GetInvalidAtomNumbers, GetUnknownAtoms,
1351 InternalBondOrderToMDLBondType, InternalBondStereochemistryToMDLBondStereo,
1352 InternalChargeToMDLCharge, InternalSpinMultiplicityToMDLRadical, IsCmpd2D,
1353 IsCmpd3D, MDLBondStereoToInternalBondStereochemistry,
1354 MDLBondTypeToInternalBondOrder, MDLChargeToInternalCharge,
1355 MDLRadicalToInternalSpinMultiplicity, ParseCmpdAtomAliasPropertyLine,
1356 ParseCmpdAtomLine, ParseCmpdBondLine, ParseCmpdChargePropertyLine,
1357 ParseCmpdCommentsLine, ParseCmpdCountsLine, ParseCmpdIsotopePropertyLine,
1358 ParseCmpdMiscInfoLine, ParseCmpdMolNameLine, ParseCmpdRadicalPropertyLine,
1359 ReadCmpdString, RemoveCmpdDataHeaderLabelAndValue, WashCmpd
1360
1361 =head1 METHODS
1362
1363 =over 4
1364
1365 =item B<GenerateCmpdAtomAliasPropertyLines>
1366
1367 @Lines = GenerateCmpdAtomAliasPropertyLines($AliasValuePairsRef);
1368
1369 Returns a formatted atom alias property lines corresponding to successive pairs
1370 of atom number and alias values specified by a refernce to an array. Two lines
1371 are generate for each atom number and alias value pairs: First line - A <AtomNum>;
1372 Second line:<AtomAlias>.
1373
1374 =item B<GenerateCmpdAtomLine>
1375
1376 $Line = GenerateCmpdAtomLine($AtomSymbol, $AtomX, $AtomY,
1377 $AtomZ, [$MassDifference, $Charge, $StereoParity]);
1378
1379 Returns a formatted atom data line containing all the input values.
1380
1381 =item B<GenerateCmpdBondLine>
1382
1383 $Line = GenerateCmpdBondLine($FirstAtomNum, $SecondAtomNum,
1384 $BondType, [$BondStereo]);
1385
1386 Returns a formatted bond data line containing all the input values.
1387
1388 =item B<GenerateCmpdChargePropertyLines>
1389
1390 @Lines = GenerateCmpdChargePropertyLines($ChargeValuePairsRef);
1391
1392 Returns a formatted M CHG property lines corresponding to successive pairs of
1393 atom number and charge values specified by a refernce to an array.
1394
1395 =item B<GenerateCmpdCommentsLine>
1396
1397 $Line = GenerateCmpdCommentsLine($Comments);
1398
1399 Returns a formatted comments data line.
1400
1401 =item B<GenerateCmpdCountsLine>
1402
1403 $Line = GenerateCmpdCountsLine($AtomCount, $BondCount,
1404 $ChiralFlag, [$PropertyCount, $Version]);
1405
1406 Returns a formatted line containing all the input values. The default values of 999
1407 and V2000 are used for I<PropertyCount> and I<Version>.
1408
1409 =item B<GenerateCmpdDataHeaderLabelsAndValuesLines>
1410
1411 @Lines = GenerateCmpdDataHeaderLabelsAndValuesLines(
1412 $DataHeaderLabelsRef, $DataHeaderLabelsAndValuesRef,
1413 [$SortDataLabels]);
1414
1415 Returns formatted data lines containing header label and values lines corresponding to
1416 all data header labels in array reference I<DataHeaderLabelsRef> with values in hash
1417 reference I<DataHeaderLabelsAndValuesRef>. By default, data header labels are
1418 not sorted and correspond to the label order in array reference I<DataHeaderLabelsRef>.
1419
1420 =item B<GenerateCmpdIsotopePropertyLines>
1421
1422 @Lines = GenerateCmpdIsotopePropertyLines($IsotopeValuePairsRef);
1423
1424 Returns a formatted M ISO property lines corresponding to successive pairs of
1425 atom number and isotope values specified by a refernce to an array.
1426
1427 =item B<GenerateCmpdMiscInfoLine>
1428
1429 $Line = GenerateCmpdMiscInfoLine([$ProgramName, $UserInitial,
1430 $Code]);
1431
1432 Returns a formatted line containing specified user initial, program name, date and code.
1433 Default values are: I<ProgramName - MayaChem; UserInitial - NULL; Code - 2D>.
1434
1435 =item B<GenerateCmpdMolNameLine>
1436
1437 $Line = GenerateCmpdMolNameLine($MolName);
1438
1439 Returns a formatted molecule name data line.
1440
1441 =item B<GenerateCmpdRadicalPropertyLines>
1442
1443 @Lines = GenerateCmpdRadicalPropertyLines($RadicalValuePairsRef);
1444
1445 Returns a formatted M CHG property lines corresponding to successive pairs of
1446 atom number and multiplicity values specified by a refernce to an array.
1447
1448 =item B<GenerateEmptyCtabBlockLines>
1449
1450 $Lines = GenerateCmpdMiscInfoLine([$Date]);
1451
1452 Returns formatted lines representing empty CTAB block.
1453
1454 =item B<GenerateMiscLineDateStamp>
1455
1456 $Line = GenerateMiscLineDateStamp();
1457
1458 Returns date stamp for misc line.
1459
1460 =item B<GetAllAndCommonCmpdDataHeaderLabels>
1461
1462 ($CmpdCount, $DataFieldLabelsArrayRef,
1463 $CommonDataFieldLabelsArrayRef) =
1464 GetAllAndCommonCmpdDataHeaderLabels(\*SDFILE);
1465
1466 Returns number of comopunds, a reference to an array containing all unique data header
1467 label and a reference to an array containing common data field labels for all compounds
1468 in SD file.
1469
1470 =item B<GetCmpdDataHeaderLabels>
1471
1472 (@Labels) = GetCmpdDataHeaderLabels(\@CmpdLines);
1473
1474 Returns an array containg data header labels for a compound
1475
1476 =item B<GetCmpdDataHeaderLabelsAndValues>
1477
1478 (%DataValues) = GetCmpdDataHeaderLabelsAndValues(\@CmpdLines);
1479
1480 Returns a hash conating data header labes and values for a compound.
1481
1482 =item B<GetCmpdFragments>
1483
1484 ($FragmentCount, $FragmentString) = GetCmpdFragments(\@CmpLines);
1485
1486 Figures out the number of disconnected fragments and return their values along
1487 with the atom numbers in a string delimited by new line character. Fragment data
1488 in B<FragmentString> is sorted on based on its size.
1489
1490 =item B<GetCtabLinesCount>
1491
1492 $CtabLinesCount = GetCtabLinesCount(\@CmpdLines);
1493
1494 Returns number of lines present between the 4th line and the line containg "M END".
1495
1496 =item B<GetInvalidAtomNumbers>
1497
1498 ($InvalidAtomNumbersCount, $InvalidAtomNumbers, $InvalidAtomNumberLines) =
1499 GetInvalidAtomNumbers(\@CmpdLines);
1500
1501 Returns a list of values containing information about invalid atom numbers present
1502 in block or atom property lines.
1503
1504 =item B<GetUnknownAtoms>
1505
1506 ($UnknownAtomCount, $UnknownAtoms, $UnknownAtomLines) =
1507 GetUnknownAtoms(\@CmpdLines);
1508
1509 Returns a list of values containing information about atoms which contain special element
1510 symbols not present in the periodic table.
1511
1512 =item B<InternalBondOrderToMDLBondType>
1513
1514 $MDLBondType = InternalBondOrderToMDLBondType($InternalBondOrder);
1515
1516 Returns value of I<MDLBondType> corresponding to I<InternalBondOrder>.
1517
1518 InternalBondOrder MDLBondType
1519
1520 1 1
1521 2 2
1522 3 3
1523 1.5 4
1524
1525 =item B<InternalBondStereochemistryToMDLBondStereo>
1526
1527 $MDLBondStereo = InternalBondStereochemistryToMDLBondStereo(
1528 $InternalBondStereo);
1529
1530 Returns value of I<MDLBondStereo> corresponding to I<InternalBondStereo> using following
1531 mapping:
1532
1533 InternalBondStereo MDLBondStereo
1534
1535 Up 1
1536 UpOrDown 4
1537 Down 6
1538 CisOrTrans 3
1539 Other 0
1540
1541 =item B<InternalChargeToMDLCharge>
1542
1543 $MDLCharge = InternalChargeToMDLCharge($InternalCharge);
1544
1545 Returns value of I<MDLCharge> corresponding to I<InternalCharge> using following
1546 mapping:
1547
1548 InternalCharge MDLCharge
1549
1550 3 1
1551 2 2
1552 1 3
1553 -1 5
1554 -2 6
1555 -3 7
1556
1557 =item B<InternalSpinMultiplicityToMDLRadical>
1558
1559 $MDLRadical = InternalSpinMultiplicityToMDLRadical(
1560 $InternalSpinMultiplicity);
1561
1562 Returns value of I<MDLRadical> corresponding to I<InternalSpinMultiplicity>. These
1563 value are equivalent.
1564
1565 =item B<MDLBondStereoToInternalBondType>
1566
1567 $InternalBondType = MDLBondStereoToInternalBondType($MDLBondStereo);
1568
1569 Returns value of I<InternalBondType> corresponding to I<MDLBondStereo> using
1570 mapping shown for B<InternalBondTypeToMDLBondStereo> function.
1571
1572 =item B<IsCmpd2D>
1573
1574 $Status = IsCmpd2D();
1575
1576 Returns 1 or 0 based on whether z-coordinate of any atom is non-zero.
1577
1578 =item B<IsCmpd3D>
1579
1580 $Status = IsCmpd3D();
1581
1582 Returns 1 or 0 based on whether z-coordinate of any atom is non-zero.
1583
1584 =item B<MDLBondStereoToInternalBondStereochemistry>
1585
1586 $InternalBondStereo = MDLBondStereoToInternalBondStereochemistry(
1587 $MDLBondStereo);
1588
1589 Returns value of I<InternalBondStereo> corresponding to I<MDLBondStereo> using
1590 mapping shown for B<InternalBondStereochemistryToMDLBondStereo> function.
1591
1592 =item B<MDLBondTypeToInternalBondOrder>
1593
1594 $InternalBondOrder = MDLBondTypeToInternalBondOrder($MDLBondType);
1595
1596 Returns value of I<InternalBondOrder> corresponding to I<MDLBondType> using
1597 mapping shown for B<InternalBondOrderToMDLBondType> function.
1598
1599 =item B<MDLChargeToInternalCharge>
1600
1601 $InternalCharge = MDLChargeToInternalCharge($MDLCharge);
1602
1603 Returns value of I<$InternalCharge> corresponding to I<MDLCharge> using
1604 mapping shown for B<InternalChargeToMDLCharge> function.
1605
1606 =item B<MDLRadicalToInternalSpinMultiplicity>
1607
1608 $InternalSpinMultiplicity = MDLRadicalToInternalSpinMultiplicity(
1609 $MDLRadical);
1610
1611 Returns value of I<InternalSpinMultiplicity> corresponding to I<MDLRadical>. These
1612 value are equivalent.
1613
1614 =item B<ParseCmpdAtomAliasPropertyLine>
1615
1616 @AtomNumAndValuePairs = ParseCmpdAtomAliasPropertyLine(
1617 $CurrentLine, $NexLine);
1618
1619 Parses atom alias propery lines in CTAB generic properties block and returns an array
1620 with successive pairs of values corresponding to atom number and its alias.
1621
1622 =item B<ParseCmpdAtomLine>
1623
1624 ($AtomSymbol, $AtomX, $AtomY, $AtomZ, $MassDifference, $Charge,
1625 $StereoParity) = ParseCmpdAtomLine($AtomDataLine);
1626
1627 Parses compound data line containing atom information and returns a list
1628 of values.
1629
1630 =item B<ParseCmpdBondLine>
1631
1632 ($FirstAtomNum, $SecondAtomNum, $BondType) =
1633 ParseCmpdBondLine($BondDataLine);
1634
1635 Parses compound data line containing bond information and returns a list of
1636 values.
1637
1638 =item B<ParseCmpdCommentsLine>
1639
1640 $Comments = ParseCmpdCommentsLine($CommentsDataLine);
1641
1642 Returns the comment string.
1643
1644 =item B<ParseCmpdChargePropertyLine>
1645
1646 @AtomNumAndValuePairs = ParseCmpdChargePropertyLine(
1647 $ChargeDataLine);
1648
1649 Parses charge propery line in CTAB generic properties block and returns an array
1650 with successive pairs of values corresponding to atom number and its charge.
1651
1652 =item B<ParseCmpdCountsLine>
1653
1654 ($AtomCount, $BondCount, $ChiralFlag, $PropertyCount, $Version) =
1655 ParseCmpdCountsLine(\@CountDataLines);
1656
1657 Returns a list of values containing count information.
1658
1659 =item B<ParseCmpdMiscInfoLine>
1660
1661 ($UserInitial, $ProgramName, $Date, $Code, $ScalingFactor1, $ScalingFactor2,
1662 $Energy, $RegistryNum) = ParseCmpdMiscInfoLine($Line);
1663
1664 Returns a list of values containing miscellaneous information.
1665
1666 =item B<ParseCmpdIsotopePropertyLine>
1667
1668 @AtomNumAndValuePairs = ParseCmpdIsotopePropertyLine(
1669 $IsotopeDataLine);
1670
1671 Parses isotopic propery line in CTAB generic properties block and returns an array
1672 with successive pairs of values corresponding to atom number and absolute mass of
1673 atom isotope.
1674
1675 =item B<ParseCmpdMolNameLine>
1676
1677 $MolName = ParseCmpdMolNameLine($Line);
1678
1679 Returns a string containing molecule name.
1680
1681 =item B<ParseCmpdRadicalPropertyLine>
1682
1683 @AtomNumAndValuePairs = ParseCmpdRadicalPropertyLine(
1684 $RadicalDataLine);
1685
1686 Parses radical propery line in CTAB generic properties block and returns an array
1687 with successive pairs of values corresponding to atom number and radical number
1688 value.
1689
1690 =item B<RemoveCmpdDataHeaderLabelAndValue>
1691
1692 $NewCmpdString = RemoveCmpdDataHeaderLabelAndValue($CmpdString,
1693 $DataHeaderLabel);
1694
1695 Returns a B<NewCmpdString> after removing I<DataHeaderLabel> along with its
1696 value from I<CmpdString>.
1697
1698 =item B<ReadCmpdString>
1699
1700 $CmpdString = ReadCmpdString(\*SDFILEHANDLE);
1701
1702 Returns a string containing all the data lines for the next available compound
1703 in an already open file indicated by SDFILEHANDLE. A NULL string is returned
1704 on EOF.
1705
1706 =item B<WashCmpd>
1707
1708 ($FragmentCount, $Fragments, $WashedCmpdString) =
1709 WashCmpd(\@CmpdLines);
1710
1711 Figures out the number of disconnected fragments and return their values along
1712 with the atom numbers in a string delimited by new line character. Fragment data
1713 in B<FragmentString> is sorted on based on its size.
1714
1715 =back
1716
1717 =head1 AUTHOR
1718
1719 Manish Sud <msud@san.rr.com>
1720
1721 =head1 SEE ALSO
1722
1723 TextUtil.pm
1724
1725 =head1 COPYRIGHT
1726
1727 Copyright (C) 2015 Manish Sud. All rights reserved.
1728
1729 This file is part of MayaChemTools.
1730
1731 MayaChemTools is free software; you can redistribute it and/or modify it under
1732 the terms of the GNU Lesser General Public License as published by the Free
1733 Software Foundation; either version 3 of the License, or (at your option)
1734 any later version.
1735
1736 =cut