Mercurial > repos > deepakjadmin > mayatool3_test2

comparison lib/Fingerprints/TopologicalPharmacophoreAtomTripletsFingerprints.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 Fingerprints::TopologicalPharmacophoreAtomTripletsFingerprints;
2 #
3 # $RCSfile: TopologicalPharmacophoreAtomTripletsFingerprints.pm,v $
4 # $Date: 2015/02/28 20:48:54 $
5 # $Revision: 1.30 $
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 Carp;
31 use Exporter;
32 use Fingerprints::Fingerprints;
33 use TextUtil ();
34 use MathUtil ();
35 use Molecule;
36 use AtomTypes::FunctionalClassAtomTypes;
37
38 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
39
40 @ISA = qw(Fingerprints::Fingerprints Exporter);
41 @EXPORT = qw();
42 @EXPORT_OK = qw();
43
44 %EXPORT_TAGS = (all => [@EXPORT, @EXPORT_OK]);
45
46 # Setup class variables...
47 my($ClassName);
48 _InitializeClass();
49
50 # Overload Perl functions...
51 use overload '""' => 'StringifyTopologicalPharmacophoreAtomTripletsFingerprints';
52
53 # Class constructor...
54 sub new {
55 my($Class, %NamesAndValues) = @_;
56
57 # Initialize object...
58 my $This = $Class->SUPER::new();
59 bless $This, ref($Class) || $Class;
60 $This->_InitializeTopologicalPharmacophoreAtomTripletsFingerprints();
61
62 $This->_InitializeTopologicalPharmacophoreAtomTripletsFingerprintsProperties(%NamesAndValues);
63
64 return $This;
65 }
66
67 # Initialize object data...
68 #
69 sub _InitializeTopologicalPharmacophoreAtomTripletsFingerprints {
70 my($This) = @_;
71
72 # Type of fingerprint...
73 $This->{Type} = 'TopologicalPharmacophoreAtomTriplets';
74
75 # Type of vector...
76 $This->{VectorType} = 'FingerprintsVector';
77
78 # AtomTripletsSetSizeToUse...
79 #
80 # ArbitrarySize - Corrresponds to atom triplets with non-zero count
81 # FixedSize - Corresponds to all atom triplets with zero and non-zero count
82 #
83 # Possible values: ArbitrarySize or FixedSize. Default: ArbitrarySize
84 #
85 $This->{AtomTripletsSetSizeToUse} = '';
86
87 #
88 # OrderedNumericalValues - For ArbitrarySize value of AtomTripletsSetSizeToUse
89 # NumericalValues - For FixedSize value of AtomTripletsSetSizeToUse
90 #
91 # Possible values: OrderedNumericalValues or NumericalValues. Default: NumericalValues
92 #
93 $This->{FingerprintsVectorType} = '';
94
95 # Minimum and maximum bond distance between pharmacophore atom pairs corresponding to
96 # atom triplets and distance bin size used for binning distances.
97 #
98 # In order to distribute distance bins of equal size, the last bin is allowed to go past the
99 # maximum distance specified by upto distance bin size.
100 #
101 # The default MinDistance and MaxDistance values of 1 and 10 with DistanceBinSize of
102 # 2 [ Ref 70 ] generates the following 5 distance bins: [1, 2] [3, 4] [5, 6] [7, 8] [9 10]
103 #
104 $This->{MinDistance} = 1;
105 $This->{MaxDistance} = 10;
106
107 # Distance bin size used for binning distances...
108 #
109 $This->{DistanceBinSize} = 2;
110
111 # Determines whether to apply triangle inequality to distances triplets during basis set generation...
112 #
113 $This->{UseTriangleInequality} = 1;
114
115 # Initialize pharmacophore atom types information...
116 $This->_InitializeToplogicalPharmacophoreAtomTypesInformation();
117
118 # Pharmacophore types assigned to each heavy atom...
119 #
120 %{$This->{AssignedAtomTypes}} = ();
121
122 # All pharmacophore atom triplets between minimum and maximum distance...
123 #
124 %{$This->{AtomTriplets}} = ();
125 @{$This->{AtomTriplets}{IDs}} = ();
126 %{$This->{AtomTriplets}{Count}} = ();
127 }
128
129 # Initialize class ...
130 sub _InitializeClass {
131 #Class name...
132 $ClassName = __PACKAGE__;
133 }
134
135 # Initialize object properties....
136 sub _InitializeTopologicalPharmacophoreAtomTripletsFingerprintsProperties {
137 my($This, %NamesAndValues) = @_;
138
139 my($Name, $Value, $MethodName);
140 while (($Name, $Value) = each %NamesAndValues) {
141 $MethodName = "Set${Name}";
142 $This->$MethodName($Value);
143 }
144
145 # Make sure molecule object was specified...
146 if (!exists $NamesAndValues{Molecule}) {
147 croak "Error: ${ClassName}->New: Object can't be instantiated without specifying molecule...";
148 }
149 $This->_InitializeTopologicalPharmacophoreAtomTripletsFingerprintsVector();
150
151 return $This;
152 }
153
154 # Initialize fingerprints vector...
155 #
156 sub _InitializeTopologicalPharmacophoreAtomTripletsFingerprintsVector {
157 my($This) = @_;
158
159 if (!$This->{AtomTripletsSetSizeToUse}) {
160 $This->{AtomTripletsSetSizeToUse} = 'ArbitrarySize';
161 }
162
163 # Vector type and type of values...
164 $This->{VectorType} = 'FingerprintsVector';
165
166 if ($This->{AtomTripletsSetSizeToUse} =~ /^FixedSize$/i) {
167 $This->{FingerprintsVectorType} = 'OrderedNumericalValues';
168 }
169 else {
170 $This->{FingerprintsVectorType} = 'NumericalValues';
171 }
172
173 $This->_InitializeFingerprintsVector();
174 }
175
176 # Set atom parits set size to use...
177 #
178 sub SetAtomTripletsSetSizeToUse {
179 my($This, $Value) = @_;
180
181 if ($This->{AtomTripletsSetSizeToUse}) {
182 croak "Error: ${ClassName}->SetAtomTripletsSetSizeToUse: Can't change size: It's already set...";
183 }
184
185 if ($Value !~ /^(ArbitrarySize|FixedSize)$/i) {
186 croak "Error: ${ClassName}->SetAtomTripletsSetSizeToUse: Unknown AtomTripletsSetSizeToUse value: $Value; Supported values: ArbitrarySize or FixedSize";
187 }
188
189 $This->{AtomTripletsSetSizeToUse} = $Value;
190
191 return $This;
192 }
193
194 # Initialize topological atom types, generated by AtomTypes::FunctionalClassAtomTypes
195 # class, to use for atom triplets fingerprint generation...
196 #
197 # Let:
198 # HBD: HydrogenBondDonor
199 # HBA: HydrogenBondAcceptor
200 # PI : PositivelyIonizable
201 # NI : NegativelyIonizable
202 # Ar : Aromatic
203 # Hal : Halogen
204 # H : Hydrophobic
205 # RA : RingAtom
206 # CA : ChainAtom
207 #
208 # Then:
209 #
210 # Functiononal class atom type specification for an atom corresponds to:
211 #
212 # Ar.CA.H.HBA.HBD.Hal.NI.PI.RA
213 #
214 # Default pharmacophore atom types [ Ref 71 ] to use for atom triplets fingerprint generation
215 # are: HBD, HBA, PI, NI, H, Ar
216 #
217 # FunctionalAtomTypes are assigned using the following definitions [ Ref 60-61, Ref 65-66 ]:
218 #
219 # HydrogenBondDonor: NH, NH2, OH
220 # HydrogenBondAcceptor: N[!H], O
221 # PositivelyIonizable: +, NH2
222 # NegativelyIonizable: -, C(=O)OH, S(=O)OH, P(=O)OH
223 #
224 sub _InitializeToplogicalPharmacophoreAtomTypesInformation {
225 my($This) = @_;
226
227 # Default pharmacophore atom types to use for atom triplets fingerprint generation
228 # are: HBD, HBA, PI, NI, H, Ar
229 #
230 @{$This->{AtomTypesToUse}} = ();
231 @{$This->{AtomTypesToUse}} = sort ('HBD', 'HBA', 'PI', 'NI', 'H', 'Ar');
232
233 return $This;
234 }
235
236 # Set atom types to use for atom triplets...
237 #
238 sub SetAtomTypesToUse {
239 my($This, @Values) = @_;
240 my($FirstValue, $TypeOfFirstValue, $AtomType, $SpecifiedAtomType, @SpecifiedAtomTypes, @AtomTypesToUse);
241
242 if (!@Values) {
243 carp "Warning: ${ClassName}->SetAtomTypesToUse: No values specified...";
244 return;
245 }
246
247 $FirstValue = $Values[0];
248 $TypeOfFirstValue = ref $FirstValue;
249
250 @SpecifiedAtomTypes = ();
251 @AtomTypesToUse = ();
252
253 if ($TypeOfFirstValue =~ /^ARRAY/) {
254 push @SpecifiedAtomTypes, @{$FirstValue};
255 }
256 else {
257 push @SpecifiedAtomTypes, @Values;
258 }
259
260 # Make sure specified AtomTypes are valid...
261 for $SpecifiedAtomType (@SpecifiedAtomTypes) {
262 if (!AtomTypes::FunctionalClassAtomTypes::IsFunctionalClassAvailable($SpecifiedAtomType)) {
263 croak "Error: ${ClassName}->SetAtomTypesToUse: Specified atom type, $SpecifiedAtomType, is not supported...\n ";
264 }
265 $AtomType = $SpecifiedAtomType;
266 push @AtomTypesToUse, $AtomType;
267 }
268
269 # Set atom types to use...
270 @{$This->{AtomTypesToUse}} = ();
271 push @{$This->{AtomTypesToUse}}, sort @AtomTypesToUse;
272
273 return $This;
274 }
275
276 # Set minimum distance for pharmacophore atom pairs in atom triplets...
277 #
278 sub SetMinDistance {
279 my($This, $Value) = @_;
280
281 if (!TextUtil::IsPositiveInteger($Value)) {
282 croak "Error: ${ClassName}->SetMinDistance: MinDistance value, $Value, is not valid: It must be a positive integer...";
283 }
284 $This->{MinDistance} = $Value;
285
286 return $This;
287 }
288
289 # Set maximum distance for pharmacophore atom pairs in atom triplets...
290 #
291 sub SetMaxDistance {
292 my($This, $Value) = @_;
293
294 if (!TextUtil::IsPositiveInteger($Value)) {
295 croak "Error: ${ClassName}->SetMaxDistance: MaxDistance value, $Value, is not valid: It must be a positive integer...";
296 }
297 $This->{MaxDistance} = $Value;
298
299 return $This;
300 }
301
302 # Set distance bin size for binning pharmacophore atom pair distances in atom triplets...
303 #
304 sub SetDistanceBinSize {
305 my($This, $Value) = @_;
306
307 if (!TextUtil::IsPositiveInteger($Value)) {
308 croak "Error: ${ClassName}->SetDistanceBinSize: DistanceBinSize value, $Value, is not valid: It must be a positive integer...";
309 }
310 $This->{DistanceBinSize} = $Value;
311
312 return $This;
313 }
314
315 # Generate fingerprints description...
316 #
317 sub GetDescription {
318 my($This) = @_;
319
320 # Is description explicity set?
321 if (exists $This->{Description}) {
322 return $This->{Description};
323 }
324
325 # Generate fingerprints description...
326
327 return "$This->{Type}:$This->{AtomTripletsSetSizeToUse}:MinDistance$This->{MinDistance}:MaxDistance$This->{MaxDistance}";
328 }
329
330 # Generate topological pharmacophore atom triplets [ Ref 66, Ref 68-71 ] fingerprints...
331 #
332 # Let:
333 #
334 # P = Any of the supported pharmacophore atom types
335 #
336 # Px = Pharmacophore atom x
337 # Py = Pharmacophore atom y
338 # Pz = Pharmacophore atom z
339 #
340 # Dxy = Distance or lower bound of binned distance between Px and Py
341 # Dxz = Distance or lower bound of binned distance between Px and Pz
342 # Dyz = Distance or lower bound of binned distance between Py and Pz
343 #
344 # Then:
345 # PxDyz-PyDxz-PzDxy = Pharmacophore atom triplet ID for atoms Px, Py and Pz
346 #
347 # For example: H1-H1-H1, H2-HBA-H2 and so on
348 #
349 # Methodology:
350 # . Generate a distance matrix.
351 # . Using specified minimum, maximum and distance bin size, generate a binned distance
352 # matrix from distance matrix. The lower distance bound on the distance bin is used
353 # in the binned distance matrix and atom triplet IDs.
354 # . Assign pharmacophore atom types to all the atoms.
355 # . Initialize pharmacophore atom triplets basis set for all unique triplets constituting
356 # atom pairs binned distances between minimum and maximum distance.
357 # . Optionally, trinagle inequality is also implied which means:
358 # . Distance or binned distance between any two pairs in a triplet must be less than the
359 # sum of distances or binned distances between other two pairs and greater than the
360 # difference of distances between other pairs.
361 # . Using binned distance matrix and pharmacophore atom types, count occurance of
362 # unique atom triplets.
363 #
364 # Notes:
365 # . Hydrogen atoms are ignored during the fingerprint generation.
366 #
367 sub GenerateFingerprints {
368 my($This) = @_;
369
370 if ($This->{MinDistance} > $This->{MaxDistance}) {
371 croak "Error: ${ClassName}->GenerateTopologicalPharmacophoreAtomTripletsFingerprints: No fingerpritns generated: MinDistance, $This->{MinDistance}, must be <= MaxDistance, $This->{MaxDistance}...";
372 }
373
374 # Cache appropriate molecule data...
375 $This->_SetupMoleculeDataCache();
376
377 # Generate distance matrix...
378 if (!$This->_SetupDistanceMatrix()) {
379 carp "Warning: ${ClassName}->GenerateFingerprints: Fingerprints generation didn't succeed: Couldn't generate distance matrix...";
380 return $This;
381 }
382
383 # Generate binned distance matrix...
384 $This->_GenerateBinnedDistanceMatrix();
385
386 # Assign pharmacohore atom types to all heavy atoms...
387 $This->_AssignPharmacophoreAtomTypes();
388
389 # Initialize values of all possible pharmacohore atom triplets...
390 $This->_InitializePharmacophoreAtomTriplets();
391
392 # Count atom triplets...
393 $This->_CountPharmacohoreAtomTriplets();
394
395 # Set final fingerprints...
396 $This->_SetFinalFingerprints();
397
398 # Clear cached molecule data...
399 $This->_ClearMoleculeDataCache();
400
401 return $This;
402 }
403
404 # Setup distance matrix...
405 #
406 sub _SetupDistanceMatrix {
407 my($This) = @_;
408
409 $This->{DistanceMatrix} = $This->GetMolecule()->GetDistanceMatrix();
410
411 if (!$This->{DistanceMatrix}) {
412 return undef;
413 }
414
415 return $This;
416 }
417
418 # Generate binned distance matrix for distances with in the specified distance ranges...
419 #
420 sub _GenerateBinnedDistanceMatrix {
421 my($This) = @_;
422 my($DistanceMatrix, $BinnedDistanceMatrix, $NumOfRows, $NumOfCols, $RowIndex, $ColIndex, $SkipIndexCheck);
423
424 $DistanceMatrix = $This->{DistanceMatrix};
425 ($NumOfRows, $NumOfCols) = $DistanceMatrix->GetSize();
426
427 # Initialize binned distance matrix...
428 $BinnedDistanceMatrix = new Matrix($NumOfRows, $NumOfCols);
429
430 # Setup distance to binned distance map...
431 my($BinnedDistance, $Distance, %DistanceToBinnedDistance);
432 %DistanceToBinnedDistance = ();
433 for ($BinnedDistance = $This->{MinDistance}; $BinnedDistance <= $This->{MaxDistance}; $BinnedDistance += $This->{DistanceBinSize}) {
434 for $Distance ($BinnedDistance .. ($BinnedDistance + $This->{DistanceBinSize} - 1)) {
435 $DistanceToBinnedDistance{$Distance} = $BinnedDistance;
436 }
437 }
438
439 # Generate binned distance matrix...
440 $SkipIndexCheck = 0;
441 for $RowIndex (0 .. ($NumOfRows - 1) ) {
442 COLINDEX: for $ColIndex (($RowIndex + 1) .. ($NumOfCols - 1) ) {
443 $Distance = $DistanceMatrix->GetValue($RowIndex, $ColIndex, $SkipIndexCheck);
444 if ($Distance < $This->{MinDistance} || $Distance > $This->{MaxDistance}) {
445 next COLINDEX;
446 }
447 $BinnedDistance = $DistanceToBinnedDistance{$Distance};
448 $BinnedDistanceMatrix->SetValue($RowIndex, $ColIndex, $BinnedDistance, $SkipIndexCheck);
449 $BinnedDistanceMatrix->SetValue($ColIndex, $RowIndex, $BinnedDistance, $SkipIndexCheck);
450 }
451 }
452
453 $This->{BinnedDistanceMatrix} = $BinnedDistanceMatrix;
454
455 return $This;
456 }
457
458 # Assign pharmacohore atom types to all heavy atoms...
459 #
460 sub _AssignPharmacophoreAtomTypes {
461 my($This) = @_;
462 my($Atom, $AtomID, $AtomType, $FunctionalClassAtomTypes);
463
464 # Assign topological pharmacophore atom types...
465 $FunctionalClassAtomTypes = new AtomTypes::FunctionalClassAtomTypes('Molecule' => $This->{Molecule}, 'IgnoreHydrogens' => 1, 'FunctionalClassesToUse' => $This->{AtomTypesToUse});
466 $FunctionalClassAtomTypes->AssignAtomTypes();
467
468 %{$This->{AssignedAtomTypes}} = ();
469
470 ATOM: for $Atom (@{$This->{Atoms}}) {
471 if ($Atom->IsHydrogen()) {
472 next ATOM;
473 }
474 $AtomID = $Atom->GetID();
475
476 my(@AtomTypes);
477 @AtomTypes = ();
478
479 $AtomType = $FunctionalClassAtomTypes->GetAtomType($Atom);
480 if ($AtomType && $AtomType !~ /^None$/i) {
481 push @AtomTypes, split /\./, $AtomType;
482 }
483 # Assign phramacophore types list to atom...
484 $This->{AssignedAtomTypes}{$AtomID} = \@AtomTypes;
485 }
486 return $This;
487 }
488
489 # Initialize pharmacophore atom triplets basis set for all unique triplets constituting atom pairs
490 # binned distances between minimum and maximum distance and optionally applying triangle
491 # inequality. The DistanceBinSize determines the size of the distance bins. The lower distance
492 # bound, along with specified pharmacophore types, is used during generation of atom triplet
493 # IDs.
494 #
495 #
496 sub _InitializePharmacophoreAtomTriplets {
497 my($This) = @_;
498 my($AtomType1, $AtomType2, $AtomType3, $BinnedDistance12, $BinnedDistance13, $BinnedDistance23, $AtomTripletID);
499
500 # Initialize atom triplets information...
501 for ($BinnedDistance12 = $This->{MinDistance}; $BinnedDistance12 <= $This->{MaxDistance}; $BinnedDistance12 += $This->{DistanceBinSize}) {
502 for ($BinnedDistance13 = $This->{MinDistance}; $BinnedDistance13 <= $This->{MaxDistance}; $BinnedDistance13 += $This->{DistanceBinSize}) {
503 DISTANCE23: for ($BinnedDistance23 = $BinnedDistance12; $BinnedDistance23 <= $This->{MaxDistance}; $BinnedDistance23 += $This->{DistanceBinSize}) {
504 if ($This->{UseTriangleInequality} && !$This->_DoDistancesSatisfyTriangleInequality($BinnedDistance12, $BinnedDistance13, $BinnedDistance23)) {
505 next DISTANCE23;
506 }
507 for $AtomType1 (@{$This->{AtomTypesToUse}}) {
508 for $AtomType2 (@{$This->{AtomTypesToUse}}) {
509 ATOMTYPE3: for $AtomType3 (@{$This->{AtomTypesToUse}}) {
510 $AtomTripletID = $This->_GetAtomTripletID($AtomType1, $BinnedDistance23, $AtomType2, $BinnedDistance13, $AtomType3, $BinnedDistance12);
511 if (exists $This->{AtomTriplets}{Count}{$AtomTripletID}) {
512 next ATOMTYPE3;
513 }
514 # Unique atom triplets information...
515 push @{$This->{AtomTriplets}{IDs}}, $AtomTripletID;
516 $This->{AtomTriplets}{Count}{$AtomTripletID} = 0;
517 }
518 }
519 }
520 }
521 }
522 }
523 return $This;
524 }
525
526 # Check triangle inequality...
527 #
528 sub _DoDistancesSatisfyTriangleInequality {
529 my($This, $Distance1, $Distance2, $Distance3) = @_;
530
531 if ( !($Distance1 > abs($Distance2 - $Distance3) && $Distance1 < ($Distance2 + $Distance3)) ) {
532 return 0;
533 }
534 if ( !($Distance2 > abs($Distance1 - $Distance3) && $Distance2 < ($Distance1 + $Distance3)) ) {
535 return 0;
536 }
537 if ( !($Distance3 > abs($Distance1 - $Distance2) && $Distance3 < ($Distance1 + $Distance2)) ) {
538 return 0;
539 }
540 return 1;
541 }
542
543 # Count pharmacophore atom triplets...
544 #
545 sub _CountPharmacohoreAtomTriplets {
546 my($This) = @_;
547 my($NumOfAtoms, $AtomIndex1, $AtomIndex2, $AtomIndex3, $AtomID1, $AtomID2, $AtomID3, $AtomType1, $AtomType2, $AtomType3, $BinnedDistance12, $BinnedDistance13, $BinnedDistance23, $SkipIndexCheck, $BinnedDistanceMatrix, $AtomTripletID);
548
549 $NumOfAtoms = @{$This->{Atoms}};
550 $BinnedDistanceMatrix = $This->{BinnedDistanceMatrix};
551 $SkipIndexCheck = 0;
552
553 ATOMINDEX1: for $AtomIndex1 (0 .. ($NumOfAtoms - 1)) {
554 $AtomID1 = $This->{AtomIndexToID}{$AtomIndex1};
555 if ( !((exists($This->{AssignedAtomTypes}{$AtomID1}) && @{$This->{AssignedAtomTypes}{$AtomID1}})) ) {
556 next ATOMINDEX1;
557 }
558
559 ATOMINDEX2: for $AtomIndex2 (($AtomIndex1 + 1) .. ($NumOfAtoms - 1)) {
560 $AtomID2 = $This->{AtomIndexToID}{$AtomIndex2};
561 if ( !((exists($This->{AssignedAtomTypes}{$AtomID2}) && @{$This->{AssignedAtomTypes}{$AtomID2}})) ) {
562 next ATOMINDEX2;
563 }
564 $BinnedDistance12 = $BinnedDistanceMatrix->GetValue($AtomIndex1, $AtomIndex2, $SkipIndexCheck);
565 if ($BinnedDistance12 == 0) {
566 next ATOMINDEX2;
567 }
568
569 ATOMINDEX3: for $AtomIndex3 (($AtomIndex2 + 1) .. ($NumOfAtoms - 1)) {
570 $AtomID3 = $This->{AtomIndexToID}{$AtomIndex3};
571 if ( !((exists($This->{AssignedAtomTypes}{$AtomID3}) && @{$This->{AssignedAtomTypes}{$AtomID3}})) ) {
572 next ATOMINDEX3;
573 }
574 $BinnedDistance13 = $BinnedDistanceMatrix->GetValue($AtomIndex1, $AtomIndex3, $SkipIndexCheck);
575 $BinnedDistance23 = $BinnedDistanceMatrix->GetValue($AtomIndex2, $AtomIndex3, $SkipIndexCheck);
576 if ($BinnedDistance13 == 0 || $BinnedDistance23 == 0) {
577 next ATOMINDEX3;
578 }
579 if ($This->{UseTriangleInequality} && !$This->_DoDistancesSatisfyTriangleInequality($BinnedDistance12, $BinnedDistance13, $BinnedDistance23)) {
580 next ATOMINDEX3;
581 }
582
583 # Go over possible pharmacohore triplets for the three pharmacophore atoms using the
584 # binned distances...
585 for $AtomType1 (@{$This->{AssignedAtomTypes}{$AtomID1}}) {
586 for $AtomType2 (@{$This->{AssignedAtomTypes}{$AtomID2}}) {
587 for $AtomType3 (@{$This->{AssignedAtomTypes}{$AtomID3}}) {
588 $AtomTripletID = $This->_GetAtomTripletID($AtomType1, $BinnedDistance23, $AtomType2, $BinnedDistance13, $AtomType3, $BinnedDistance12);
589 $This->{AtomTriplets}{Count}{$AtomTripletID} += 1;
590 }
591 }
592 }
593 }
594 }
595 }
596 return $This;
597 }
598
599 # Set final fingerpritns vector...
600 #
601 sub _SetFinalFingerprints {
602 my($This) = @_;
603 my($UseArbitrarySetSize, $ID, $Value, @IDs, @Values);
604
605 # Mark successful generation of fingerprints...
606 $This->{FingerprintsGenerated} = 1;
607
608 # Is it an ArbitraySize atom triplets set size?
609 $UseArbitrarySetSize = $This->{AtomTripletsSetSizeToUse} =~ /^ArbitrarySize$/i ? 1 : 0;
610
611 # Set atom triplet count values...
612 @IDs = (); @Values = ();
613
614 if ($UseArbitrarySetSize) {
615 ID: for $ID (@{$This->{AtomTriplets}{IDs}}) {
616 $Value = $This->{AtomTriplets}{Count}{$ID};
617 if ($Value == 0) {
618 next ID;
619 }
620 push @IDs, $ID;
621 push @Values, $Value;
622 }
623 }
624 else {
625 @Values = map { $This->{AtomTriplets}{Count}{$_} } @{$This->{AtomTriplets}{IDs}};
626 }
627
628 # Set atom triplet IDs for fingerprint vector...
629 if ($UseArbitrarySetSize) {
630 $This->{FingerprintsVector}->AddValueIDs(\@IDs);
631 }
632 else {
633 $This->{FingerprintsVector}->AddValueIDs(\@{$This->{AtomTriplets}{IDs}});
634 }
635
636 # Set atom triplets count values for fingerprint vector...
637 $This->{FingerprintsVector}->AddValues(\@Values);
638
639 return $This;
640 }
641
642 # Return an array or reference to an array containing atom triplet IDs...
643 #
644 sub GetAtomTripletIDs {
645 my($This) = @_;
646
647 return wantarray ? @{$This->{AtomTriplets}{IDs}} : \@{$This->{AtomTriplets}{IDs}};
648 }
649
650 # Get pharmacophore atom triplet ID corresponding to atom types and distances
651 # corresponding to atom triplet...
652 #
653 sub _GetAtomTripletID {
654 my($This, $Px, $Dyz, $Py, $Dxz, $Pz, $Dxy) = @_;
655 my($AtomTripletID, @AtomIDs);
656
657 @AtomIDs = ();
658
659 @AtomIDs = sort("${Px}${Dyz}", "${Py}${Dxz}", "${Pz}${Dxy}");
660 $AtomTripletID = join "-", @AtomIDs;
661
662 return $AtomTripletID;
663 }
664
665 # Cache appropriate molecule data...
666 #
667 sub _SetupMoleculeDataCache {
668 my($This) = @_;
669
670 # Get all atoms including hydrogens to correctly map atom indices to atom IDs for
671 # usage of distance matrix. The hydrogen atoms are ignored during processing...
672 #
673 @{$This->{Atoms}} = $This->GetMolecule()->GetAtoms();
674
675 # Get all atom IDs...
676 my(@AtomIDs);
677 @AtomIDs = ();
678 @AtomIDs = map { $_->GetID() } @{$This->{Atoms}};
679
680 # Set AtomIndex to AtomID hash...
681 %{$This->{AtomIndexToID}} = ();
682 @{$This->{AtomIndexToID}}{ (0 .. $#AtomIDs) } = @AtomIDs;
683
684 return $This;
685 }
686
687 # Clear cached molecule data...
688 #
689 sub _ClearMoleculeDataCache {
690 my($This) = @_;
691
692 @{$This->{Atoms}} = ();
693
694 return $This;
695 }
696
697
698 # Return a string containg data for TopologicalPharmacophoreAtomTripletsFingerprints object...
699 #
700 sub StringifyTopologicalPharmacophoreAtomTripletsFingerprints {
701 my($This) = @_;
702 my($FingerprintsString, $UseTriangleInequality);
703
704 # Type of fingerprint...
705 $FingerprintsString = "Fingerprint type: $This->{Type}; AtomTripletsSetSizeToUse: $This->{AtomTripletsSetSizeToUse}";
706
707 # Distances information...
708 $FingerprintsString .= "; MinDistance: $This->{MinDistance}; MaxDistance: $This->{MaxDistance}; DistanceBinSize: $This->{DistanceBinSize}; UseTriangleInequality: " . ($This->{UseTriangleInequality} ? "Yes" : "No");
709
710 # Pharmacophore atom type labels and description...
711 my($AtomType, @AtomTypes, @AtomTypesOrder, %AvailableAtomTypes);
712
713 @AtomTypesOrder = AtomTypes::FunctionalClassAtomTypes::GetFunctionalClassesOrder();
714 %AvailableAtomTypes = AtomTypes::FunctionalClassAtomTypes::GetAvailableFunctionalClasses();
715
716 @AtomTypes = ();
717 for $AtomType (@AtomTypesOrder) {
718 push @AtomTypes, "$AtomType: $AvailableAtomTypes{$AtomType}";
719 }
720
721 $FingerprintsString .= "; AtomTypesToUse: <" . TextUtil::JoinWords(\@{$This->{AtomTypesToUse}}, ", ", 0) . ">";
722 $FingerprintsString .= "; AtomTypesOrder: <" . TextUtil::JoinWords(\@AtomTypesOrder, ", ", 0) . ">";
723 $FingerprintsString .= "; AvailableAtomTypes: <" . TextUtil::JoinWords(\@AtomTypes, ", ", 0) . ">";
724
725 # Total number of pharmacophore atom triplets...
726 $FingerprintsString .= "; NumOfAtomTriplets: " . $This->{FingerprintsVector}->GetNumOfValues();
727
728 # FingerprintsVector...
729 $FingerprintsString .= "; FingerprintsVector: < $This->{FingerprintsVector} >";
730
731 return $FingerprintsString;
732 }
733
734 1;
735
736 __END__
737
738 =head1 NAME
739
740 TopologicalPharmacophoreAtomTripletsFingerprints
741
742 =head1 SYNOPSIS
743
744 use Fingerprints::TopologicalPharmacophoreAtomTripletsFingerprints;
745
746 use Fingerprints::TopologicalPharmacophoreAtomTripletsFingerprints qw(:all);
747
748 =head1 DESCRIPTION
749
750 B<TopologicalPharmacophoreAtomTripletsFingerprints> [ Ref 66, Ref 68-71 ] class provides
751 the following methods:
752
753 new, GenerateFingerprints, , GetDescription, GetAtomTripletIDs,
754 SetAtomTypesToUse, SetDistanceBinSize, SetMaxDistance, SetMinDistance,
755 StringifyTopologicalPharmacophoreAtomTripletsFingerprints
756
757 B<TopologicalPharmacophoreAtomTripletsFingerprints> is derived from B<Fingerprints> class
758 which in turn is derived from B<ObjectProperty> base class that provides methods not explicitly
759 defined in B<TopologicalPharmacophoreAtomTripletsFingerprints>, B<Fingerprints> or B<ObjectProperty>
760 classes using Perl's AUTOLOAD functionality. These methods are generated on-the-fly for a specified
761 object property:
762
763 Set<PropertyName>(<PropertyValue>);
764 $PropertyValue = Get<PropertyName>();
765 Delete<PropertyName>();
766
767 Based on the values specified for B<AtomTypesToUse>, pharmacophore atom types are
768 assigned to all non-hydrogen atoms in a molecule and a distance matrix is generated.
769 Using B<MinDistance>, B<MaxDistance>, and B<DistanceBinSize> values, a
770 binned distance matrix is generated with lower bound on the distance bin as the distance
771 in distance matrix; the lower bound on the distance bin is also used as the distance between
772 atom pairs for generation of atom triplet identifiers.
773
774 A pharmacophore atom triplets basis set is generated for all unique atom triplets constituting
775 atom pairs binned distances between B<--MinDistance> and B<--MaxDistance>. The value
776 of B<--UseTriangleInequality> determines whether the triangle inequality test is applied during
777 generation of atom triplets basis set. The lower distance bound, along with specified pharmacophore
778 types, is used during generation of atom triplet IDs.
779
780 Let:
781
782 P = Valid pharmacophore atom type
783
784 Px = Pharmacophore atom x
785 Py = Pharmacophore atom y
786 Pz = Pharmacophore atom z
787
788 Dmin = Minimum distance corresponding to number of bonds between two atoms
789 Dmax = Maximum distance corresponding to number of bonds between two atoms
790 D = Distance corresponding to number of bonds between two atom
791
792 Bsize = Distance bin size
793 Nbins = Number of distance bins
794
795 Dxy = Distance or lower bound of binned distance between Px and Py
796 Dxz = Distance or lower bound of binned distance between Px and Pz
797 Dyz = Distance or lower bound of binned distance between Py and Pz
798
799 Then:
800
801 PxDyz-PyDxz-PzDxy = Pharmacophore atom triplet IDs for atom types Px,
802 Py, and Pz
803
804 For example: H1-H1-H1, H2-HBA-H2 and so on.
805
806 For default values of Dmin = 1 , Dmax = 10 and Bsize = 2, the number of
807 distance bins, Nbins = 5, are:
808
809 [1, 2] [3, 4] [5, 6] [7, 8] [9 10]
810
811 and atom triplet basis set size is 2692.
812
813 Atom triplet basis set size for various values of Dmin, Dmax and Bsize in
814 conjunction with usage of triangle inequality is:
815
816 Dmin Dmax Bsize UseTriangleInequality TripletBasisSetSize
817 1 10 2 No 4960
818 1 10 2 Yes 2692 [ Default ]
819 2 12 2 No 8436
820 2 12 2 Yes 4494
821
822
823 Using binned distance matrix and pharmacohore atom types, occurrence of unique pharmacohore
824 atom triplets is counted.
825
826 The final pharmacophore atom triples count along with atom pair identifiers involving all non-hydrogen
827 atoms constitute pharmacophore topological atom triplets fingerprints of the molecule.
828
829 For I<ArbitrarySize> value of B<AtomTripletsSetSizeToUse>, the fingerprint vector correspond to
830 only those topological pharmacophore atom triplets which are present and have non-zero count. However,
831 for I<FixedSize> value of B<AtomTripletsSetSizeToUse>, the fingerprint vector contains all possible
832 valid topological pharmacophore atom triplets with both zero and non-zero count values.
833
834 The current release of MayaChemTools generates the following types of topological pharmacophore
835 atom triplets fingerprints vector strings:
836
837 FingerprintsVector;TopologicalPharmacophoreAtomTriplets:ArbitrarySize:
838 MinDistance1:MaxDistance10;696;NumericalValues;IDsAndValuesString;Ar1-
839 Ar1-Ar1 Ar1-Ar1-H1 Ar1-Ar1-HBA1 Ar1-Ar1-HBD1 Ar1-H1-H1 Ar1-H1-HBA1 Ar1
840 -H1-HBD1 Ar1-HBA1-HBD1 H1-H1-H1 H1-H1-HBA1 H1-H1-HBD1 H1-HBA1-HBA1 H1-
841 HBA1-HBD1 H1-HBA1-NI1 H1-HBD1-NI1 HBA1-HBA1-NI1 HBA1-HBD1-NI1 Ar1-...;
842 46 106 8 3 83 11 4 1 21 5 3 1 2 2 1 1 1 100 101 18 11 145 132 26 14 23
843 28 3 3 5 4 61 45 10 4 16 20 7 5 1 3 4 5 3 1 1 1 1 5 4 2 1 2 2 2 1 1 1
844 119 123 24 15 185 202 41 25 22 17 3 5 85 95 18 11 23 17 3 1 1 6 4 ...
845
846 FingerprintsVector;TopologicalPharmacophoreAtomTriplets:FixedSize:MinD
847 istance1:MaxDistance10;2692;OrderedNumericalValues;ValuesString;46 106
848 8 3 0 0 83 11 4 0 0 0 1 0 0 0 0 0 0 0 0 21 5 3 0 0 1 2 2 0 0 1 0 0 0
849 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 100 101 18 11 0 0 145 132 26
850 14 0 0 23 28 3 3 0 0 5 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 61 45 10 4 0
851 0 16 20 7 5 1 0 3 4 5 3 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 5 ...
852
853 FingerprintsVector;TopologicalPharmacophoreAtomTriplets:FixedSize:MinD
854 istance1:MaxDistance10;2692;OrderedNumericalValues;IDsAndValuesString;
855 Ar1-Ar1-Ar1 Ar1-Ar1-H1 Ar1-Ar1-HBA1 Ar1-Ar1-HBD1 Ar1-Ar1-NI1 Ar1-Ar1-P
856 I1 Ar1-H1-H1 Ar1-H1-HBA1 Ar1-H1-HBD1 Ar1-H1-NI1 Ar1-H1-PI1 Ar1-HBA1-HB
857 A1 Ar1-HBA1-HBD1 Ar1-HBA1-NI1 Ar1-HBA1-PI1 Ar1-HBD1-HBD1 Ar1-HBD1-...;
858 46 106 8 3 0 0 83 11 4 0 0 0 1 0 0 0 0 0 0 0 0 21 5 3 0 0 1 2 2 0 0 1
859 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 100 101 18 11 0 0 145
860 132 26 14 0 0 23 28 3 3 0 0 5 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 61 ...
861
862 =head2 METHODS
863
864 =over 4
865
866 =item B<new>
867
868 $TPATFP = new TopologicalPharmacophoreAtomTripletsFingerprints(
869 %NamesAndValues);
870
871 Using specified I<TopologicalPharmacophoreAtomTripletsFingerprints> property names and values hash, B<new>
872 method creates a new object and returns a reference to newly created B<TopologicalPharmacophoreAtomTripletsFingerprints>
873 object. By default, the following properties are initialized:
874
875 Molecule = ''
876 Type = 'TopologicalPharmacophoreAtomTriplets'
877 MinDistance = 1
878 MaxDistance = 10
879 DistanceBinSize = 2
880 UseTriangleInequality = 1
881 AtomTypesToUse = ['HBD', 'HBA', 'PI', 'NI', 'H', 'Ar']
882
883 Examples:
884
885 $TPATFP = new TopologicalPharmacophoreAtomTripletsFingerprints(
886 'Molecule' => $Molecule);
887
888 $TPATFP = new TopologicalPharmacophoreAtomTripletsFingerprints(
889 'Molecule' => $Molecule,
890 'AtomTripletsSetSizeToUse' => 'ArbitrarySize';
891 'MinDistance' => 1,
892 'MaxDistance' => 10,
893 'DistanceBinSize' => 2,
894 'AtomTypesToUse' => ['HBD', 'HBA', 'PI', 'NI', 'H', 'Ar'],
895 'UseTriangleInequality' => 1);
896
897 $TPATFP = new TopologicalPharmacophoreAtomTripletsFingerprints(
898 'Molecule' => $Molecule,
899 'AtomTripletsSetSizeToUse' => 'FixedSize';
900 'MinDistance' => 1,
901 'MaxDistance' => 10,
902 'DistanceBinSize' => 2,
903 'AtomTypesToUse' => ['HBD', 'HBA', 'PI', 'NI', 'H', 'Ar'],
904 'UseTriangleInequality' => 1);
905
906 $TPATFP->GenerateFingerprints();
907 print "$TPATFP\n";
908
909 =item B<GetDescription>
910
911 $Description = $TopologicalPharmacophoreAtomTripletsFP->GetDescription();
912
913 Returns a string containing description of topological pharmacophore atom triplets fingerprints.
914
915 =item B<GenerateFingerprints>
916
917 $TopologicalPharmacophoreAtomTripletsFP->GenerateFingerprints();
918
919 Generates topological pharmacophore atom triplets fingerprints and returns
920 I<TopologicalPharmacophoreAtomTripletsFP>.
921
922 =item B<GetAtomTripletIDs>
923
924 $AtomTripletsIDsRef = $TopologicalPharmacophoreATFP->GetAtomTripletIDs();
925 @AtomTripletIDs = $TopologicalPharmacophoreATFP->GetAtomTripletIDs();
926
927 Returns atom triplet IDs corresponding to atom pairs count values in topological pharmacophore
928 atom triplet fingerprints vector as an array or reference to an array.
929
930 =item B<AtomTripletsSetSizeToUse>
931
932 $TPAFP->AtomTripletsSetSizeToUse($Values);
933
934 Sets pharmacophore atom triplets set size to use for topological pharmacophore fingerprints
935 generation and returns I<TopologicalPharmacophoreAtomTripletsFingerprints>.
936
937 Possible values for pharmacophore atom triplets set size are: I<ArbitrarySize, FizedSize>.
938 Default value: I<ArbitrarySize>.
939
940 For I<ArbitrarySize> value of B<AtomTripletsSetSizeToUse>, the fingerprint vector correspond to
941 only those topological pharmacophore atom triplets which are present and have non-zero count. However,
942 for I<FixedSize> value of B<AtomTripletsSetSizeToUse>, the fingerprint vector contains all possible
943 valid topological pharmacophore atom triplets with both zero and non-zero count values.
944
945 =item B<SetAtomTypesToUse>
946
947 $TopologicalPharmacophoreAtomTripletsFP->SetAtomTypesToUse($ValuesRef);
948 $TopologicalPharmacophoreAtomTripletsFP->SetAtomTypesToUse(@Values);
949
950 Sets pharmacophore atom types to use for topological pharmacophore fingerprints
951 generation and returns I<TopologicalPharmacophoreAtomTripletsFingerprints>.
952
953 Possible values for pharmacophore atom types are: I<Ar, CA, H, HBA, HBD, Hal, NI, PI, RA>.
954 Default value [ Ref 71 ] : I<HBD,HBA,PI,NI,H,Ar>.
955
956 The pharmacophore atom types abbreviations correspond to:
957
958 HBD: HydrogenBondDonor
959 HBA: HydrogenBondAcceptor
960 PI : PositivelyIonizable
961 NI : NegativelyIonizable
962 Ar : Aromatic
963 Hal : Halogen
964 H : Hydrophobic
965 RA : RingAtom
966 CA : ChainAtom
967
968 I<AtomTypes::FunctionalClassAtomTypes> module is used to assign pharmacophore atom
969 types. It uses following definitions [ Ref 60-61, Ref 65-66 ]:
970
971 HydrogenBondDonor: NH, NH2, OH
972 HydrogenBondAcceptor: N[!H], O
973 PositivelyIonizable: +, NH2
974 NegativelyIonizable: -, C(=O)OH, S(=O)OH, P(=O)OH
975
976
977 =item B<SetDistanceBinSize>
978
979 $TopologicalPharmacophoreAtomTripletsFP->SetDistanceBinSize($Value);
980
981 Sets distance bin size used to bin distances between atom pairs in atom triplets and returns
982 I<TopologicalPharmacophoreAtomTriplesFP>.
983
984 For default B<MinDistance> and B<MaxDistance> values of 1 and 10 with B<DistanceBinSize>
985 of 2 [ Ref 70 ], the following 5 distance bins are generated:
986
987 [1, 2] [3, 4] [5, 6] [7, 8] [9 10]
988
989 The lower distance bound on the distance bin is uses to bin the distance between atom pairs in
990 atom triplets. So in the previous example, atom pairs with distances 1 and 2 fall in first distance
991 bin, atom pairs with distances 3 and 4 fall in second distance bin and so on.
992
993 In order to distribute distance bins of equal size, the last bin is allowed to go past B<MaxDistance>
994 by up to distance bin size. For example, B<MinDistance> and B<MaxDistance> values of 2 and 10
995 with B<DistanceBinSize> of 2 generates the following 6 distance bins:
996
997 [2, 3] [4, 5] [6, 7] [8, 9] [10 11]
998
999
1000 =item B<SetMaxDistance>
1001
1002 $TopologicalPharmacophoreAtomTriplesFP->SetMaxDistance($Value);
1003
1004 Sets maximum bond distance between atom pairs corresponding to atom triplets for
1005 generating topological pharmacophore atom triplets fingerprints and returns
1006 I<TopologicalPharmacophoreAtomTriplesFP>.
1007
1008 =item B<SetMinDistance>
1009
1010 $TopologicalPharmacophoreAtomTriplesFP->SetMinDistance($Value);
1011
1012 Sets minimum bond distance between atom pairs corresponding to atom triplets for
1013 generating topological pharmacophore atom triplets fingerprints and returns
1014 I<TopologicalPharmacophoreAtomTriplesFP>.
1015
1016 =item B<StringifyTopologicalPharmacophoreAtomTripletsFingerprints>
1017
1018 $String = $TopologicalPharmacophoreAtomTripletsFingerprints->
1019 StringifyTopologicalPharmacophoreAtomTripletsFingerprints();
1020
1021 Returns a string containing information about I<TopologicalPharmacophoreAtomTripletsFingerprints> object.
1022
1023 =back
1024
1025 =head1 AUTHOR
1026
1027 Manish Sud <msud@san.rr.com>
1028
1029 =head1 SEE ALSO
1030
1031 Fingerprints.pm, FingerprintsStringUtil.pm, AtomNeighborhoodsFingerprints.pm,
1032 AtomTypesFingerprints.pm, EStateIndiciesFingerprints.pm, ExtendedConnectivityFingerprints.pm,
1033 MACCSKeys.pm, PathLengthFingerprints.pm, TopologicalAtomPairsFingerprints.pm,
1034 TopologicalAtomTripletsFingerprints.pm, TopologicalAtomTorsionsFingerprints.pm,
1035 TopologicalPharmacophoreAtomPairsFingerprints.pm,
1036
1037 =head1 COPYRIGHT
1038
1039 Copyright (C) 2015 Manish Sud. All rights reserved.
1040
1041 This file is part of MayaChemTools.
1042
1043 MayaChemTools is free software; you can redistribute it and/or modify it under
1044 the terms of the GNU Lesser General Public License as published by the Free
1045 Software Foundation; either version 3 of the License, or (at your option)
1046 any later version.
1047
1048 =cut