|
0
|
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
|
