comparison docs/modules/txt/Atom.txt @ 0:4816e4a8ae95 draft default tip

Uploaded
author deepakjadmin
date Wed, 20 Jan 2016 09:23:18 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4816e4a8ae95
1 NAME
2 Atom
3
4 SYNOPSIS
5 use Atom;
6
7 DESCRIPTION
8 Atom class provides the following methods:
9
10 new, AddHydrogens, Copy, DeleteAtom, DeleteHydrogens,
11 DoesAtomNeighborhoodMatch, GetAtomicInvariantValue, GetAtomicWeight,
12 GetBondToAtom, GetBonds, GetBondsToHeavyAtoms, GetBondsToHydrogenAtoms,
13 GetBondsToNonHydrogenAtoms, GetExactMass, GetExplicitHydrogens,
14 GetFormalCharge, GetFreeRadicalElectrons, GetGroupNumber,
15 GetHeavyAtomNeighbors, GetHeavyAtomNeighborsAtomInformation,
16 GetHeavyAtomNeighborsBondformation, GetHighestCommonValence,
17 GetHydrogenAtomNeighbors, GetHydrogens, GetImplicitHydrogens,
18 GetLargestBondOrder, GetLargestBondOrderToHeavyAtoms,
19 GetLargestBondOrderToNonHydrogenAtoms, GetLargestRing,
20 GetLowestCommonValence, GetMassNumber, GetMissingHydrogens,
21 GetNeighbors, GetNeighborsUsingAtomSpecification,
22 GetNonHydrogenAtomNeighbors, GetNonHydrogenAtomNeighborsAtomInformation,
23 GetNonHydrogenAtomNeighborsBondInformation,
24 GetNonHydrogenNeighborOfHydrogenAtom, GetNumOfAromaticBondsToHeavyAtoms,
25 GetNumOfAromaticBondsToNonHydrogenAtoms, GetNumOfBondTypesToHeavyAtoms,
26 GetNumOfBondTypesToNonHydrogenAtoms, GetNumOfBonds,
27 GetNumOfBondsToHeavyAtoms, GetNumOfBondsToHydrogenAtoms,
28 GetNumOfBondsToNonHydrogenAtoms, GetNumOfDoubleBondsToHeavyAtoms,
29 GetNumOfBondsAvailableForHeavyAtoms,
30 GetNumOfBondsAvailableForNonHydrogenAtoms,
31 GetNumOfDoubleBondsToNonHydrogenAtoms, GetNumOfExplicitHydrogens,
32 GetNumOfHeavyAtomNeighbors, GetNumOfHydrogenAtomNeighbors,
33 GetNumOfHydrogens, GetNumOfImplicitHydrogens, GetNumOfMissingHydrogens,
34 GetNumOfNeighbors, GetNumOfNonHydrogenAtomNeighbors, GetNumOfRings,
35 GetNumOfRingsWithEvenSize, GetNumOfRingsWithOddSize,
36 GetNumOfRingsWithSize, GetNumOfRingsWithSizeGreaterThan,
37 GetNumOfRingsWithSizeLessThan, GetNumOfSigmaAndPiBondsToHeavyAtoms,
38 GetNumOfSigmaAndPiBondsToNonHydrogenAtoms,
39 GetNumOfSingleBondsToHeavyAtoms, GetNumOfSingleBondsToNonHydrogenAtoms,
40 GetNumOfTripleBondsToHeavyAtoms, GetNumOfTripleBondsToNonHydrogenAtoms,
41 GetPeriodNumber, GetPotentialTotalCommonValence, GetRings,
42 GetRingsWithEvenSize, GetRingsWithOddSize, GetRingsWithSize,
43 GetRingsWithSizeGreaterThan, GetRingsWithSizeLessThan,
44 GetSizeOfLargestRing, GetSizeOfSmallestRing, GetSmallestRing,
45 GetSpinMultiplicity, GetSumOfBondOrders, GetSumOfBondOrdersToHeavyAtoms,
46 GetSumOfBondOrdersToHydrogenAtoms, GetSumOfBondOrdersToNonHydrogenAtoms,
47 GetValence, GetValenceElectrons, GetValenceFreeElectrons, GetX, GetXYZ,
48 GetXYZVector, GetY, GetZ, IsAmideCarbon, IsAmideNitrogen, IsAromatic,
49 IsArsenic, IsBondedToAtom, IsBromine, IsCarbon, IsCarboxylCarbon,
50 IsCarboxylOxygen, IsCarboxylateCarbon, IsCarboxylateOxygen, IsChlorine,
51 IsFluorine, IsFunctionalClassType, IsGuadiniumCarbon,
52 IsGuadiniumNitrogen, IsHBondAcceptor, IsHBondDonor, IsHalogen,
53 IsHeteroAtom, IsHydrogen, IsHydrogenBondAcceptor, IsHydrogenBondDonor,
54 IsHydrophobic, IsInRing, IsInRingOfSize, IsIodine, IsIsotope,
55 IsLipophilic, IsMetallic, IsNegativelyIonizable, IsNitrogen,
56 IsNonCarbonOrHydrogen, IsNotInRing, IsOnlyInOneRing, IsOxygen,
57 IsPhosphateOxygen, IsPhosphatePhosphorus, IsPhosphorus, IsPolarAtom,
58 IsPolarHydrogen, IsPositivelyIonizable, IsSaturated, IsSelenium,
59 IsSilicon, IsStereoCenter, IsSulfur, IsSulphur, IsTellurium, IsTerminal,
60 IsTopologicalPharmacophoreType, IsUnsaturated, SetAtomSymbol,
61 SetAtomicNumber, SetExplicitHydrogens, SetMassNumber, SetStereoCenter,
62 SetStereochemistry, SetX, SetXYZ, SetY, SetZ, StringifyAtom
63
64 Atom class is derived from ObjectProperty base class which provides
65 methods not explicitly defined in Atom or ObjectProperty class using
66 Perl's AUTOLOAD functionality. These methods are generated on-the-fly
67 for a specified object property:
68
69 Set<PropertyName>(<PropertyValue>);
70 $PropertyValue = Get<PropertyName>();
71 Delete<PropertyName>();
72
73 METHODS
74 new
75 $NewAtom = new Atom([%PropertyNameAndValues]);
76
77 Using specified *Atom* property names and values hash, new method
78 creates a new object and returns a reference to newly created Atom
79 object. By default, following properties are initialized:
80
81 ID = SequentialObjectID
82 Name = "Atom <SequentialObjectID>"
83 AtomSymbol = ""
84 AtomicNumber = 0
85 XYZ = ZeroVector
86
87 Except for *ID* property, all other default properties and other
88 additional properties can be set during invocation of this method.
89
90 Examples:
91
92 $Atom = new Atom();
93 $CarbonAtom = new Atom('AtomSymbol' => 'C', 'XYZ' => (0.0, 1.0,
94 0.0));
95 $OxygenAtom = new Atom('AtomName' => 'Oxygen', AtomSymbol' => 'O',
96 'XYZ' => (1.0, 1.0, 1.0));
97
98 AddHydrogens
99 $NumOfHydrogensAdded = $Atom->AddHydrogens();
100
101 Adds hydrogens to an Atom present in a Molecule object and returns
102 the number of added hydrogens. The current release of MayaChemTools
103 doesn't assign hydrogen positions.
104
105 Copy
106 $AtomCopy = $Atom->Copy();
107
108 Copy *Atom* and its associated data using Storable::dclone and
109 return a new Atom object.
110
111 DeleteAtom
112 $Atom->DeleteAtom();
113
114 Delete *Atom* from a molecule.
115
116 DoesAtomNeighborhoodMatch
117 $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec);
118 $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec,
119 $NbrAtomSpecsRef);
120 $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec,
121 $NbrAtomSpecsRef, $AllowedNbrBondSpecsRef);
122 $Status = $Atom->DoesAtomNeighborhoodMatch($CentralAtomSpec,
123 $NbrAtomSpecsRef, $NbrBondSpecsRef,
124 $AllowedNbrOfNbrAtomSpecsRef);
125
126 Returns 1 or 0 based on whether atom matches central atom and its
127 neighborhood using specified atom and bonds specifications.
128 Neighborhood atom and bond specifications are specified as array
129 references containing neighbor atom and bond specifications.
130
131 Let:
132
133 AS = Atom symbol corresponding to element symbol, atomic number (#n)
134 or any atom (A)
135
136 X<n> = Number of non-hydrogen atom neighbors or heavy atoms
137 attached to atom
138 T<n> = Total number of atom neighbors including implicit and explicit
139 hydrogens
140 BO<n> = Sum of bond orders to non-hydrogen atom neighbors or heavy
141 atoms attached to atom
142 LBO<n> = Largest bond order of non-hydrogen atom neighbors or heavy
143 atoms attached to atom
144 SB<n> = Number of single bonds to non-hydrogen atom neighbors or
145 heavy atoms attached to atom
146 TSB<n> = Total number of single bonds to atom neighbors including implicit
147 and explicit hydrogens
148 DB<n> = Number of double bonds to non-hydrogen atom neighbors or
149 heavy atoms attached to atom
150 TB<n> = Number of triple bonds to non-hydrogen atom neighbors or
151 heavy atoms attached to atom
152 AB<n> = Number of aromatic bonds to non-hydrogen atom neighbors or
153 heavy atoms attached to atom
154 H<n> = Number of implicit and explicit hydrogens for atom
155 Ar = Aromatic annotation indicating whether atom is aromatic
156 RA or RA<n> = Ring atom annotation indicating whether atom
157 is a ring
158 TR<n> = Total number of rings containing atom
159 FC<+n/-n> = Formal charge assigned to atom
160 MN<n> = Mass number indicating isotope other than most abundant isotope
161 SM<n> = Spin multiplicity of atom. Possible values: 1 (singlet),
162 2 (doublet) or 3 (triplet)
163
164 Then, atom specification corresponds to:
165
166 AS.X<n>.T<n>.BO<n>.LBO<n>.<SB><n>.TSB<n>.<DB><n>.<TB><n>.AB<n>.H<n>.Ar.
167 RA<n>.TR<n>FC<+n/-n>.MN<n>.SM<n>
168
169 Except for AS which is a required atomic invariant in atom
170 specification, all other atomic invariants are optional. For an atom
171 specification to match an atom, the values of all specified atomic
172 invariants must match. Exclamation in from of atomic invariant can
173 be used to negate its effect during the match.
174
175 For *FC* value matching, the following value operators are also
176 supported:
177
178 o +* : Any positive value
179 o -* : Any negative value
180 o > ValidNumber or >= ValidNumber
181 o < ValidNumber or <= ValidNumber
182
183 A comma delimited atom specification string is used to match any one
184 of the specified atom specification.
185
186 Notes:
187
188 o During atom specification match to an atom, the first atomic invariant is always assumed to
189 atom symbol.
190
191 Examples:
192
193 o ('N', 'N', 'N')
194 o ('N.FC0', 'N.FC0', 'N,N.FC+1.H1')
195 o ('N.H2', 'N.H2', 'N.H1')
196 o ('C,N', '!N', '!H')
197 o ('C,N', 'N.Ar', 'N.R5')
198
199 Let:
200
201 -|1|s|Single = Single bond
202 =|2|d|Double = Double bond
203 #|3|t|Triple = Triple bond
204 :|1.5|a|Ar|Aromatic = Aromatic bond
205
206 @|RB|Ring = Ring bond
207 ~|*|Any = Any bond
208
209 Then, bond specification corresponds to:
210
211 -.:
212 =.@
213 Double.Aromatic
214
215 For a bond specification to match bond between two atoms, the values
216 of all specified bond symbols must match. Exclamation in from of
217 bond symbol can be used to negate its effect during the match.
218
219 A comma delimited bond specification string is used to match any one
220 of the specified atom specification.
221
222 Notes:
223
224 o During atom neighborhood match for central atom neighborhood atom and bond specifications,
225 implicit or missing hydrogens are automatically checked for any matches to unmatched
226 specifications.
227
228 Examples:
229
230 Aromatic carbon in a 5 membered ring:
231 $Atom->DoesAtomNeighborhoodMatch('C.Ar.RA5');
232
233 AcetylenicCarbon: $Atom->DoesAtomNeighborhoodMatch('C.T2.TB1'); or
234 $Atom->DoesAtomNeighborhoodMatch('C.T2.TB1',
235 ['*', '*'], ['#', '-']);
236
237 GuadiniumCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4',
238 ['N.FC0', 'N.FC0', 'N.FC0,N.FC+1'],
239 ['-', '-', '='],
240 ['C,H', 'C,H', 'C,H']);
241
242 AmideCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4,C.X2.BO3',
243 ['C,H', 'O', 'N'],
244 ['-', '=', '-'],
245 ['C,H', 'C', 'C,H,N,O,S,P,F,Cl,Br,I']);
246
247 CarboxylCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4,C.X2.BO3',
248 ['C,H', 'O', 'O.X1.FC0'],
249 ['-', '=', '-'],
250 ['C,H', 'C', 'C']);
251
252 CarboxylateCarbon: $Atom->DoesAtomNeighborhoodMatch('C.X3.BO4,C.X2.BO3',
253 ['C,H', 'O', 'O.X1.FC-1'],
254 ['-', '=', '-'],
255 ['C,H', 'C', 'C']);
256
257 DeleteHydrogens
258 $NumOfHydrogensDeleted = $Atom->AddHydrogens();
259
260 Delete hydrogens from an Atom present in a Molecule object and
261 returns the number of deleted hydrogens.
262
263 GetAtomicInvariantValue
264 $Value = $Atom->GetAtomicInvariantValue($AtomicInvariant);
265
266 Returns atomic invariant value for a specified *AtomicInvariant*.
267 The current release of MayaChemTools supports following
268 abbreviations and descriptive names for *AtomicInvarints*:
269
270 AS : Atom or element symbol
271 X : NumOfNonHydrogenAtomNeighbors or NumOfHeavyAtomNeighbors
272 T : TotalNumOfAtomNeighbors
273 BO : SumOfBondOrdersToNonHydrogenAtoms or SumOfBondOrdersToHeavyAtoms
274 LBO : LargestBondOrderToNonHydrogenAtoms or LargestBondOrderToHeavyAtoms
275 SB : NumOfSingleBondsToNonHydrogenAtoms or NumOfSingleBondsToHeavyAtoms
276 TSB : TotalNumOfSingleBonds
277 DB : NumOfDoubleBondsToNonHydrogenAtoms or NumOfDoubleBondsToHeavyAtoms
278 TB : NumOfTripleBondsToNonHydrogenAtoms or NumOfTripleBondsToHeavyAtoms
279 AB : NumOfAromaticBondsToNonHydrogenAtoms or NumOfAromaticBondsToHeavyAtoms
280 H : NumOfImplicitAndExplicitHydrogens
281 Ar : Aromatic
282 Str : Stereochemistry
283 RA : RingAtom
284 FC : FormalCharge
285 AN : AtomicNumber
286 AM : AtomicMass
287 MN : MassNumber
288 SM : SpinMultiplicity
289
290 GetAtomicWeight
291 $Value = $Aom->GetAtomicWeight();
292
293 Returns atomic weight of an Atom which corresponds to either
294 explicity set *AtomicWeight* atom property or atomic weight of the
295 corresponding element in the periodic table available by
296 PeriodicTable module.
297
298 GetBondToAtom
299 $Bond = $Atom->GetBondToAtom($OtherAtom);
300
301 Returns a Bond object corresponding to bond between *Atom* and
302 *OtherAtom* in a molecule.
303
304 GetBonds
305 @Bonds = $Aoto->GetBonds();
306
307 Returns an array of Bond objects corresponding to all bonds from
308 *Atom* to other bonded atoms in a molecule.
309
310 GetBondsToHeavyAtoms
311 @Bonds = $Atom->GetBondsToHeavyAtoms();
312
313 Returns an array of Bond objects corresponding to bonds from *Atom*
314 to other bonded non-hydrogen atoms in a molecule.
315
316 GetBondsToHydrogenAtoms
317 @Bonds = $Atom->GetBondsToHydrogenAtoms();
318
319 Returns an array of Bond objects corresponding to bonds from *Atom*
320 to any other hydrogen atom in a molecule.
321
322 GetBondsToNonHydrogenAtoms
323 @Bonds = $Atom->GetBondsToNonHydrogenAtoms();
324
325 Returns an array of Bond objects corresponding to bonds from *Atom*
326 to other bonded non-hydrogen atoms in a molecule.
327
328 GetExactMass
329 $ExactMass = $Atom->GetExactMass();
330
331 Returns exact mass of an *Atom* which correspond to one of these
332 three values: explicity set *ExactMass* property; mass of natural
333 isotope for an explicty set value of *MassNumber*; most abundant
334 natural isotope mass for *Atom* with valid atomic number value
335 available by PerodicTable module.
336
337 GetExplicitHydrogens
338 $NumOfExplicitHydrogens = $Atom->GetExplicitHydrogens();
339
340 Returns number of hydrogens explicity bonded to an *Atom* in a
341 molecule.
342
343 GetFormalCharge
344 $FormalCharge = $Atom->GetFormalCharge();
345
346 Returns formal charge of an *Atom* in a molecule.
347
348 GetFreeRadicalElectrons
349 $FreeRadicalElectrons = $Atom->GetFreeRadicalElectrons();
350
351 Returns number of free radical electrons corresponding to to one of
352 these three values: *FreeRadicalElectrons* property;
353 *SpinMultiplicity* property; value of 0.
354
355 For atoms with explicit assignment of *SpinMultiplicity* atom
356 property values,
357
358 Singlet - two unparied electrons corresponding to one spin state
359 Doublet - free radical; an unpaired electron corresponding to two
360 spin states
361 Triplet - two unparied electrons corresponding to three spin states
362 (divalent carbon atoms: carbenes)
363
364 FreeRadicalElectrons are calculated as follows:
365
366 Doublet: 1 (one valence electron not available for bonding)
367 Singlet: 2 (two valence electrons not available for bonding)
368 Triplet: 2 (two valence electrons not available for bonding)
369
370 GetGroupNumber
371 $GroupNumber = $Atom->GetGroupNumber();
372
373 Returns group number of an *Atom* in a molecule with a valid atomic
374 number.
375
376 GetHeavyAtomNeighbors
377 $NumOfHeavyAtoms = $Atom->GetHeavyAtomNeighbors();
378 @HeavyAtoms = $Atom->GetHeavyAtomNeighbors();
379
380 Return number of heavy atoms or an array of Atom objects
381 corresponding to heavy atoms bonded to an *Atom* in a molecule.
382
383 GetHeavyAtomNeighborsAtomInformation
384 ($NumOfAtomNeighbors, $AtomNeighborsRef,
385 $NumOfAtomNeighborsType, $AtomNeighborsTypeMapRef) = $Atom->
386 GetHeavyAtomNeighborsAtomInformation();
387
388 Returns atoms information for all non-hydrogen atoms attached to an
389 *Atom* in a molecule.
390
391 The following values are returned:
392
393 o Number of non-hydrogen atom neighbors
394 o A reference to an array containing atom objects corresponding to
395 non-hydrogen atom neighbors
396 o Number of different types of non-hydrogen atom neighbors
397 o A reference to a hash containing atom symbol as key with value
398 corresponding to its count for non-hydrogen atom neighbors
399
400 GetHeavyAtomNeighborsBondformation
401 ($NumOfBonds, $BondTypeCountMapRef,
402 $AtomsBondTypesCountMapRef,
403 $AtomsBondTypeAtomsMap) = $Atom->
404 GetHeavyAtomNeighborsBondformation();
405
406 Returns bonds information for all non-hydrogen atoms attached to an
407 *Atom* in a molecule.
408
409 The following values are returned:
410
411 o Number of bonds to non-hydrogen atom neighbors
412 o A reference to an array containing bond objects corresponding to
413 non-hydrogen atom neighbors
414 o A reference to a hash containing bond type as key with value
415 corresponding to its count for non-hydrogen atom neighbors. Bond
416 types are: Single, Double or Triple
417 o A reference to a hash containing atom symbol as key pointing to bond
418 type as second key with values corresponding to count of bond types for atom
419 symbol for non-hydrogen atom neighbors
420 o A reference to a hash containing atom symbol as key pointing to bond
421 type as second key with values corresponding to atom objects array involved
422 in corresponding bond type for atom symbol for non-hydrogen atom neighbors
423
424 GetHighestCommonValence
425 $HighestCommonValence = $Atom->GetHighestCommonValence();
426
427 Returns highest common valence of an *Atom* which corresponds to
428 either explicity set *HighestCommonValence* atom property or highest
429 common valence of the corresponding element in the periodic table
430 available by PerodicTable module.
431
432 GetHydrogens
433 $NumOfHydrogens = $Atom->GetHydrogens();
434
435 Returns total number of hydrogens for an *Atom* in a molecule
436 including both hydrogen atom neighbors and implicit hydrogens.
437
438 GetHydrogenAtomNeighbors
439 $NumOfHydrogenAtomNeighbors = $Atom->GetHydrogenAtomNeighbors();
440 @HydrogenAtomNeighbors = $Atom->GetHydrogenAtomNeighbors();
441
442 Return number of hydrogen atoms or an array of *Atom* objects
443 corresponding to hydrogen atoms bonded to an *Atom* in a molecule.
444
445 GetImplicitHydrogens
446 $NumOfImplicitHydrogens = $Atom->GetImplicitHydrogens();
447
448 Returns number of implicit hydrogens for an *Atom* in a molecule.
449 This value either corresponds to explicitly set *ImplicitHydrogens*
450 atom property or calculated as the difference between the value of
451 potential total valence and sum of bond orders to both hydrogen and
452 non-hydrogen atom neighbors.
453
454 GetPotentialTotalCommonValence
455 $PotentialTotalValence = $Atom->GetPotentialTotalCommonValence();
456
457 Returns potential total common valence of an *Atom* in a molecule
458 corresponding to a specific valence model set for the molecule using
459 its SetValenceModel method or default internal valence model. It is
460 used during the calculation of missing or implicit hydrogens.
461
462 The current release of MayaChemTools supports three valence models:
463 *MDLValenceModel, DaylightValenceModel, InternalValenceModel or
464 MayaChemToolsValenceModel*.
465
466 For *MDLValenceModel* and *DaylightValenceModel*, the following data
467 files, distributed with the package, are used to calculate potential
468 total valence:
469
470 lib/data/MDLValenceModelData.csv
471 lib/data/DaylightValenceModelData.csv
472
473 The calculation of potential total common valence for these two
474 models is performed as follows: Calculate current effective total
475 valence of the *Atom* by adding up the bond order of its neighbors
476 and number of free radical electrons; Find available common valence
477 for the *Atom*, corresponding to any specified formal charge, higher
478 than the effective total valence, and return it as
479 *PotentialTotalValence*.
480
481 The calculation of potential total common valence For
482 *InternalValenceModel* or *MayaChenToolsValenceModel* doesn't uses
483 PeriodicTable module to retrieve values for common valence, which in
484 turn reads in PeriodicTableElements.csv file distributed with the
485 package.
486
487 For elements with one one common valence, potential total common
488 valence corresponds to:
489
490 CommonValence + FormalCharge - FreeRadicalElectrons
491
492 For elements with multiple common valences, each common valence is
493 used to calculate total potential common valence as shown above, and
494 the first total potential common valence greater than the sum of
495 bond orders to all neighbors is selected as the final total common
496 valence.
497
498 FormalCharge sign is reversed for electropositive elements with
499 positive formal charge during common valence calculations.
500 Electropositive elements, metals and transition elements, have
501 usually plus formal charge and it leads to decrease in common
502 valence; the negative formal charge should result in the decrease of
503 common valence.
504
505 The sign of formal charge is adjusted as follows.
506
507 Group numbers > 14 - Group numbers 15 (N), 16 (O), 17 (F), 18 (He):
508
509 Formal charge sign is not adjusted. Positive and negative values
510 result in the increase and decrease of valence.
511
512 Group 14 containing C, Si, Ge, Sn, Pb...:
513
514 Formal charge sign is reversed for positive values. Both positive
515 and negative values result in the decrease of valence.
516
517 Group 13 containing B, Al, Ga, In, Tl...:
518
519 Formal charge sign is always reversed. Positive and negative values
520 result in the decrease and increase of valence.
521
522 Groups 1 (H) through 12 (Zn)...:
523
524 Formal charge sign is reversed for positive values. Both positive
525 and negative values result in the decrease of valence.
526
527 Lanthanides and actinides:
528
529 Formal charge sign is reversed for positive values. Both positive
530 and negative values result in the decrease of valence.
531
532 GetLargestBondOrder
533 $LargestBO =$Atom->GetLargestBondOrder();
534
535 Returns largest bond order for an *Atom* among the bonds to other
536 atoms in a molecule.
537
538 GetLargestBondOrderToHeavyAtoms
539 $LargestBO =$Atom->GetLargestBondOrderToHeavyAtoms();
540
541 Returns largest bond order for an *Atom* among the bonds to other
542 heavy atoms in a molecule.
543
544 GetLargestBondOrderToNonHydrogenAtoms
545 $LargestBO =$Atom->GetLargestBondOrderToNonHydrogenAtoms();
546
547 Returns largest bond order for an *Atom* among the bonds to other
548 non-hydrogen atoms in a molecule.
549
550 GetLargestRing
551 @RingAtoms = $Atom->GetLargestRing();
552
553 Returns an array of ring *Atom* objects corresponding to the largest
554 ring containing *Atom* in a molecule.
555
556 GetLowestCommonValence
557 $LowestCommonValence = $Atom->GetLowestCommonValence();
558
559 Returns lowest common valence of an *Atom* which corresponds to
560 either explicity set *LowestCommonValence* atom property or highest
561 common valence of the corresponding element in the periodic table
562 available by PerodicTable module.
563
564 GetMassNumber
565 $MassNumber = $Aom->GetMassNumber();
566
567 Returns atomic weight of an Atom which corresponds to either
568 explicity set *MassNumber* atom property or mass number of the most
569 abundant natural isotope of the corresponding element in the
570 periodic table available by PeriodicTable module.
571
572 GetMissingHydrogens
573 $NumOfMissingHydrogens = $Atom->GetMissingHydrogens();
574
575 Returns number of missing hydrogens for an *Atom* in a molecule.
576 This value either corresponds to explicitly set *ImplicitHydrogens*
577 atom property or calculated as the difference between the value of
578 potential total valence and sum of bond orders to both hydrogen and
579 non-hydrogen atom neighbors.
580
581 GetNeighbors
582 $NumOfNeighbors = $Atom->GetNeighbors();
583 @Neighbors = $Atom->GetNeighbors();
584
585 Returns number of neighbor atoms or an array of *Atom* objects
586 corresponding to all atoms bonded to an *Atom* in a molecule.
587
588 GetNeighborsUsingAtomSpecification
589 @AtomNeighbors = $Atom->GetNeighborsUsingAtomSpecification($AtomSpec);
590 $NumOfNeighbors = $Atom->GetNeighborsUsingAtomSpecification($AtomSpec);
591
592 @AtomNeighbors = $Atom->GetNeighborsUsingAtomSpecification($AtomSpec,
593 @ExcludeNeighbors);
594
595 Returns number of neighbor atoms or an array of *Atom* objects
596 matching atom specification corresponding to atom neighbors of an
597 *Atom* in a molecule. Optionally, *Atom* neighbors can be excluded
598 from the neighbors list using *ExcludeNeighbors*.
599
600 Notes:
601
602 o AtomSpecification correspond to any valid AtomicInvariant based atomic specifications
603 as supported by DoesAtomNeighborhoodMatch method
604 o Multiple atom specifications can be used in a string delimited by comma
605
606 GetNonHydrogenAtomNeighbors
607 $NumOfNeighbors = $Atom->GetNonHydrogenAtomNeighbors();
608 @Neighbors = $Atom->GetNonHydrogenAtomNeighbors();
609
610 Returns number of non-hydrogen atoms or an array of Atom objects
611 corresponding to non-hydrogen atoms bonded to an *Atom* in a
612 molecule.
613
614 GetNonHydrogenAtomNeighborsAtomInformation
615 ($NumOfAtomNeighbors, $AtomNeighborsRef,
616 $NumOfAtomNeighborsType, $AtomNeighborsTypeMapRef) = $Atom->
617 GetNonHydrogenAtomNeighborsAtomInformation();
618
619 Returns atoms information for all non-hydrogen atoms attached to an
620 *Atom* in a molecule.
621
622 The following values are returned:
623
624 o Number of non-hydrogen atom neighbors
625 o A reference to an array containing atom objects corresponding to
626 non-hydrogen atom neighbors
627 o Number of different types of non-hydrogen atom neighbors
628 o A reference to a hash containing atom symbol as key with value
629 corresponding to its count for non-hydrogen atom neighbors
630
631 GetNonHydrogenAtomNeighborsBondInformation
632 ($NumOfBonds, $BondTypeCountMapRef,
633 $AtomsBondTypesCountMapRef,
634 $AtomsBondTypeAtomsMap) = $Atom->
635 GetNonHydrogenAtomNeighborsBondInformation();
636
637 Returns bonds information for all non-hydrogen atoms attached to an
638 *Atom* in a molecule.
639
640 The following values are returned:
641
642 o Number of bonds to non-hydrogen atom neighbors
643 o A reference to an array containing bond objects corresponding to
644 non-hydrogen atom neighbors
645 o A reference to a hash containing bond type as key with value
646 corresponding to its count for non-hydrogen atom neighbors. Bond
647 types are: Single, Double or Triple
648 o A reference to a hash containing atom symbol as key pointing to bond
649 type as second key with values corresponding to count of bond types for atom
650 symbol for non-hydrogen atom neighbors
651 o A reference to a hash containing atom symbol as key pointing to bond
652 type as second key with values corresponding to atom objects array involved
653 in corresponding bond type for atom symbol for non-hydrogen atom neighbors
654
655 GetNonHydrogenNeighborOfHydrogenAtom
656 $Atom = $Atom->GetNonHydrogenNeighborOfHydrogenAtom();
657
658 Returns non-hydrogen or heavy atom neighbor of a hydrogen atom in a
659 molecule..
660
661 GetNumOfAromaticBondsToHeavyAtoms
662 $NumOfBonds = $Atom->GetNumOfAromaticBondsToHeavyAtoms();
663
664 Returns number of aromatic bonds from an *Atom* to other
665 non-hydrogen or heavy atoms in a molecule.
666
667 GetNumOfAromaticBondsToNonHydrogenAtoms
668 $NumOfBonds = $Atom->GetNumOfAromaticBondsToNonHydrogenAtoms();
669
670 Returns number of aromatic bonds from an *Atom* to other
671 non-hydrogen or heavy atoms in a molecule.
672
673 GetNumOfBonds
674 $NumOfBonds = $Atom->GetNumOfBonds();
675
676 Returns number of bonds from an *Atom* to other atoms in a molecule.
677
678 GetNumOfBondsAvailableForHeavyAtoms
679 $NumOfBonds = $Atom->GetNumOfBondsAvailableForHeavyAtoms();
680
681 Get number of bonds available to form additional bonds with heavy
682 atoms, excluding any implicit bonds to hydrogens set using
683 *ImplicitHydrogens* property.
684
685 It's different from number of implicit or missing hydrogens, both of
686 which are equivalent.
687
688 For example, in a SMILES string, [nH] ring atom corresponds to an
689 aromatic nitrogen. Although the hydrogen specified for n is treated
690 internally as implicit hydrogen and shows up in missing hydrogen
691 count, it's not available to participate in double bonds to
692 additional heavy atoms.
693
694 GetNumOfBondsAvailableForNonHydrogenAtoms
695 $NumOfBonds = $Atom->GetNumOfBondsAvailableForNonHydrogenAtoms();
696
697 Get number of bonds available to form additional bonds with heavy
698 atoms, excluding any implicit bonds to hydrogens set using
699 ImplicitHydrogens property.
700
701 GetNumOfBondsToHeavyAtoms
702 $NumOfBondsToHeavyAtoms = $Atom->GetNumOfBondsToHeavyAtoms();
703
704 Returns number of bonds from an *Atom* to other heavy atoms in a
705 molecule.
706
707 GetNumOfBondsToHydrogenAtoms
708 $NumOfBonds = $Atom->GetNumOfBondsToHydrogenAtoms();
709
710 Returns number of bonds from an *Atom* to other hydrogen atoms in a
711 molecule.
712
713 GetNumOfBondsToNonHydrogenAtoms
714 $NumOfBonds = $Atom->GetNumOfBondsToNonHydrogenAtoms();
715
716 Returns number of bonds from an *Atom* to other non-hydrogen atoms
717 in a molecule.
718
719 GetNumOfBondTypesToHeavyAtoms
720 ($NumOfSingleBonds, $NumOfDoubleBonds,
721 $NumOfTripleBonds, $NumOfAromaticBonds) = $Atom->
722 GetNumOfBondTypesToHeavyAtoms($CountAromaticBonds);
723
724 Get number of single, double, triple, and aromatic bonds from an
725 *Atom* to all other non-hydrogen atoms in a molecule.
726
727 Value of *CountAtomaticBonds* parameter controls whether number of
728 aromatic bonds is returned; default is not to count aromatic bonds.
729 During counting of aromatic bonds, the bond marked aromatic is not
730 included in the count of other bond types.
731
732 GetNumOfBondTypesToNonHydrogenAtoms
733 ($NumOfSingleBonds, $NumOfDoubleBonds,
734 $NumOfTripleBonds, $NumOfAromaticBonds) = $Atom->
735 GetNumOfBondTypesToNonHydrogenAtoms($CountAromaticBonds);
736
737 Get number of single, double, triple, and aromatic bonds from an
738 *Atom* to all other non-hydrogen atoms in a molecule.
739
740 Value of *CountAtomaticBonds* parameter controls whether number of
741 aromatic bonds is returned; default is not to count aromatic bonds.
742 During counting of aromatic bonds, the bond marked aromatic is not
743 included in the count of other bond types.
744
745 GetNumOfDoubleBondsToHeavyAtoms
746 $NumOfDoubleBonds = $Atom->GetNumOfDoubleBondsToHeavyAtoms();
747
748 Returns number of double bonds from an *Atom* to other heavy atoms
749 or non-hydrogen atoms in a molecule.
750
751 GetNumOfDoubleBondsToNonHydrogenAtoms
752 $NumOfDoubleBonds =$Atom->GetNumOfDoubleBondsToNonHydrogenAtoms();
753
754 Returns number of double bonds from an *Atom* to other heavy atoms
755 or non-hydrogen atoms in a molecule.
756
757 GetNumOfHeavyAtomNeighbors
758 $NumOfNeighbors = $Atom->GetNumOfHeavyAtomNeighbors();
759
760 Returns number heavy atom neighbors for an *Atom* in a molecule.
761
762 GetNumOfHydrogenAtomNeighbors
763 $NumOfNeighbors = $Atom->GetNumOfHydrogenAtomNeighbors();
764
765 Returns number hydrogens atom neighbors for an *Atom* in a molecule.
766
767 GetNumOfMissingHydrogens
768 $NumOfMissingHydrogens = $Atom->GetNumOfMissingHydrogens();
769
770 Returns number of implicit hydrogens for an *Atom* in a molecule.
771 This value either corresponds to explicitly set *ImplicitHydrogens*
772 atom property or calculated as the difference between the value of
773 potential total valence and sum of bond orders to both hydrogen and
774 non-hydrogen atom neighbors.
775
776 GetNumOfExplicitHydrogens
777 $NumOfExplicitHydrogens = $Atom->GetNumOfExplicitHydrogens();
778
779 Returns number hydrogens atom neighbors for an *Atom* in a molecule.
780
781 GetNumOfHydrogens
782 $NumOfHydrogens = $Atom->GetNumOfHydrogens();
783
784 Returns total number of hydrogens for an *Atom* in a molecule
785 including both hydrogen atom neighbors and implicit hydrogens.
786
787 GetNumOfImplicitHydrogens
788 $NumOfImplicitHydrogens = $Atom->GetNumOfImplicitHydrogens();
789
790 Returns number of implicit hydrogens for an *Atom* in a molecule.
791 This value either corresponds to explicitly set *ImplicitHydrogens*
792 atom property or calculated as the difference between the value of
793 potential total valence and sum of bond orders to both hydrogen and
794 non-hydrogen atom neighbors.
795
796 GetNumOfNeighbors
797 $NumOfNeighbors = $Atom->GetNumOfNeighbors();
798
799 Returns number atom neighbors for an *Atom* in a molecule.
800
801 GetNumOfNonHydrogenAtomNeighbors
802 $NumNeighbors = $This->GetNumOfNonHydrogenAtomNeighbors();
803
804 Returns number non-hydrogens atom neighbors for an *Atom* in a
805 molecule.
806
807 GetNumOfRings
808 $NumOfRings = $Atom->GetNumOfRings();
809
810 Returns number of rings containing *Atom* in a molecule.
811
812 GetNumOfRingsWithEvenSize
813 $NumOfRings = $Atom->GetNumOfRingsWithEvenSize();
814
815 Returns number of rings with even size containing *Atom* in a
816 molecule.
817
818 GetNumOfRingsWithOddSize
819 $NumOfRings = $Atom->GetNumOfRingsWithOddSize();
820
821 Returns number of rings with odd size containing *Atom* in a
822 molecule.
823
824 GetNumOfRingsWithSize
825 $NumOfRings = $Atom->GetNumOfRingsWithSize($RingSize);
826
827 Returns number of rings with specific *RingSize* containing *Atom*
828 in a molecule.
829
830 GetNumOfRingsWithSizeGreaterThan
831 $NumOfRings = $Atom->GetNumOfRingsWithSizeGreaterThan($RingSize);
832
833 Returns number of rings with size greater than specific *RingSize*
834 containing *Atom* in a molecule.
835
836 GetNumOfRingsWithSizeLessThan
837 $NumOfRings = $Atom->GetNumOfRingsWithSizeLessThan($RingSize);
838
839 Returns number of rings with size less than specific *RingSize*
840 containing *Atom* in a molecule.
841
842 GetNumOfSigmaAndPiBondsToHeavyAtoms
843 ($NumOfSigmaBonds, $NumOfPiBonds) = $Atom->
844 GetNumOfSigmaAndPiBondsToHeavyAtoms();
845
846 Get number of sigma and pi bonds from an *Atom* to all other
847 non-hydrogen atoms in a molecule.
848
849 Sigma and pi bonds are counted using the following methodology: a
850 single bond correspond to one sigma bond; a double bond contributes
851 one to sigma bond count and one to pi bond count; a triple bond
852 contributes one to sigma bond count and two to pi bond count.
853
854 GetNumOfSigmaAndPiBondsToNonHydrogenAtoms
855 ($NumOfSigmaBonds, $NumOfPiBonds) = $Atom->
856 GetNumOfSigmaAndPiBondsToNonHydrogenAtoms();
857
858 Get number of sigma and pi bonds from an *Atom* to all other
859 non-hydrogen atoms in a molecule.
860
861 Sigma and pi bonds are counted using the following methodology: a
862 single bond correspond to one sigma bond; a double bond contributes
863 one to sigma bond count and one to pi bond count; a triple bond
864 contributes one to sigma bond count and two to pi bond count.
865
866 GetNumOfSingleBondsToNonHydrogenAtoms
867 $NumOfSingleBonds =$Atom->GetNumOfSingleBondsToNonHydrogenAtoms();
868
869 Returns number of single bonds from an *Atom* to other heavy atoms
870 or non-hydrogen atoms in a molecule.
871
872 GetNumOfSingleBondsToHeavyAtoms
873 $NumOfSingleBonds = $Atom->GetNumOfSingleBondsToHeavyAtoms();
874
875 Returns number of single bonds from an *Atom* to other heavy atoms
876 or non-hydrogen atoms in a molecule.
877
878 GetNumOfTripleBondsToNonHydrogenAtoms
879 $NumOfTripleBonds =$Atom->GetNumOfTripleBondsToNonHydrogenAtoms();
880
881 Returns number of triple bonds from an *Atom* to other heavy atoms
882 or non-hydrogen atoms in a molecule.
883
884 GetNumOfTripleBondsToHeavyAtoms
885 $NumOfTripleBonds = $Atom->GetNumOfTripleBondsToHeavyAtoms();
886
887 Returns number of triple bonds from an *Atom* to other heavy atoms
888 or non-hydrogen atoms in a molecule.
889
890 GetPeriodNumber
891 $PeriodNumber = $Atom->GetPeriodNumber();
892
893 Returns periodic table period number for an *Atom* in a molecule
894 with a valid atomic number .
895
896 GetRings
897 @Rings = $Aotm->GetRings();
898
899 Returns an array of references to arrays containing ring atoms
900 corressponding to all rings containing *Atom* in a molecule.
901
902 GetRingsWithEvenSize
903 @Rings = $Aotm->GetRingsWithEvenSize();
904
905 Returns an array of references to arrays containing ring atoms
906 corressponding to all rings with even size containing *Atom* in a
907 molecule.
908
909 GetRingsWithOddSize
910 @Rings = $Aotm->GetRingsWithOddSize();
911
912 Returns an array of references to arrays containing ring atoms
913 corressponding to all rings with odd size containing *Atom* in a
914 molecule.
915
916 GetRingsWithSize
917 @Rings = $Aotm->GetRingsWithSize($RingSize);
918
919 Returns an array of references to arrays containing ring atoms
920 corressponding to all rings with specific *RingSize *containing
921 *Atom* in a molecule.
922
923 GetRingsWithSizeGreaterThan
924 @Rings = $Aotm->GetRingsWithSizeGreaterThan($RingSize);
925
926 Returns an array of references to arrays containing ring atoms
927 corressponding to all rings with size greater than specific
928 *RingSize *containing *Atom* in a molecule.
929
930 GetRingsWithSizeLessThan
931 @Rings = $Aotm->GetRingsWithSizeLessThan($RingSize);
932
933 Returns an array of references to arrays containing ring atoms
934 corressponding to all rings with size less than specific *RingSize
935 *containing *Atom* in a molecule.
936
937 GetSizeOfLargestRing
938 $Size = $Atom->GetSizeOfLargestRing();
939
940 Returns size of the largest ring containing *Atom* in a molecule.
941
942 GetSizeOfSmallestRing
943 $Size = $Atom->GetSizeOfSmallestRing();
944
945 Returns size of the smallest ring containing *Atom* in a molecule.
946
947 GetSmallestRing
948 @RingAtoms = $Atom->GetSmallestRing();
949
950 Returns an array of ring *Atom* objects corresponding to the largest
951 ring containing *Atom* in a molecule.
952
953 GetSpinMultiplicity
954 $SpinMultiplicity = $Atom->GetSpinMultiplicity();
955
956 Returns spin multiplicity of an *Atom* corresponding to one of these
957 three values: explicitly set SpinMultiplicity property value;
958 calculated from FreeRadicalElectrons property; value of 0.
959
960 The SpinMultiplicity is calculate from *FreeRadicalElectrons*
961 property as follows:
962
963 FreeRadicalElectrons: 1; SpinMultiplicity: 2
964 FreeRadicalElectrons: 2; SpinMultiplicity: 1
965 FreeRadicalElectrons: other; SpinMultiplicity: 0
966
967 GetSumOfBondOrders
968 $SumBondOrders = $Atom->GetSumOfBondOrders();
969
970 Returns sum of bond orders corresponding to all atoms bonded to an
971 *Atom* in a molecule.
972
973 GetSumOfBondOrdersToHeavyAtoms
974 $SumBondOrders = $Atom->GetSumOfBondOrdersToHeavyAtoms();
975
976 Returns sum of bond orders corresponding to all heavy atoms bonded
977 to an *Atom* in a molecule.
978
979 GetSumOfBondOrdersToHydrogenAtoms
980 $SumBondOrders = $Atom->GetSumOfBondOrdersToHydrogenAtoms();
981
982 Returns sum of bond orders corresponding to all hydrogen atoms
983 bonded to an *Atom* in a molecule.
984
985 GetSumOfBondOrdersToNonHydrogenAtoms
986 $SumBondOrders = $Atom->GetSumOfBondOrdersToNonHydrogenAtoms();
987
988 Returns sum of bond orders corresponding to all non-hydrogen atoms
989 bonded to an *Atom* in a molecule.
990
991 GetValence
992 $Valence = $Atom->GetValence();
993
994 Returns valence of an *Atom* in a molecule. Valence corresponds to
995 number of electrons used by an atom in bonding:
996
997 Valence = ValenceElectrons - ValenceFreeElectrons = BondingElectrons
998
999 Single, double and triple bonds with bond orders of 1, 2, and 3
1000 correspond to contribution of 1, 2, and 3 bonding electrons. So:
1001
1002 Valence = SumOfBondOrders + NumOfMissingHydrogens + FormalCharge
1003
1004 where positive and negative values of FormalCharge increase and
1005 decrease the number of bonding electrons, respectively.
1006
1007 The current release of MayaChemTools supports the following three
1008 valence models, which are used during calculation of implicit
1009 hydrogens: MDLValenceModel, DaylightValenceModel,
1010 InternalValenceModel or MayaChemToolsValenceModel.
1011
1012 Notes:
1013
1014 . Missing hydrogens are included in the valence.
1015 . For neutral molecules, valence and sum of bond orders are equal.
1016 . For molecules containing only single bonds, SumOfBondOrders and
1017 NumOfBonds are equal.
1018 . Free radical electrons lead to the decrease in valence. For atoms with
1019 explicit assignment of SpinMultiplicity property values corresponding to
1020 Singlet (two unparied electrons corresponding to one spin state), Doublet
1021 (free radical; an unpaired electron corresponding to two spin states),
1022 and Triplet (two unparied electrons corresponding to three spin states;
1023 divalent carbon atoms (carbenes)), FreeRadicalElectrons are calculated as follows:
1024
1025 SpinMultiplicity: Doublet(2); FreeRadicalElectrons: 1 (one valence
1026 electron not available for bonding)
1027 SpinMultiplicity: Singlet(1)/Triplet(3); FreeRadicalElectrons: 2 (two
1028 valence electrons not available for bonding)
1029
1030 GetValenceElectrons
1031 $ValenceElectrons = $Atom->GetValenceElectrons();
1032
1033 Returns valence electrons for an Atom which corresponds to either
1034 explicity set *ValenceElectrons* atom property or valence electrons
1035 for the corresponding element in the periodic table available by
1036 PeriodicTable module.
1037
1038 GetValenceFreeElectrons
1039 $ValenceFreeElectrons = $Atom->GetValenceFreeElectrons();
1040 $ValenceFreeElectrons = $Atom->GetValenceFreeElectrons(
1041 $ExcludeFreeRadicalElectrons);
1042
1043 Returns valence frees electrons for an Atom in a molecule. It
1044 corresponds to:
1045
1046 ValenceElectrons - Valence
1047 or
1048 ValenceElectrons - NumOfMissingHydrogens - SumOfBondOrders - FormalCharge
1049
1050 Free radical electrons are included in the valence free electrons
1051 count by default.
1052
1053 Examples:
1054
1055 NH3: ValenceFreeElectrons = 5 - 3 = 5 - 3 - 0 - 0 = 2
1056 NH2: ValenceFreeElectrons = 5 - 3 = 5 - 2 - 1 - 0 = 2
1057 NH4+; ValenceFreeElectrons = 5 - 5 = 5 - 4 - 0 - 1 = 0
1058 NH3+; ValenceFreeElectrons = 5 - 5 = 5 - 3 - 1 - 1 = 0
1059 C(=O)O- : ValenceFreeElectrons on O- = 6 - 0 = 6 - 1 - 0 - (-1) = 6
1060 C(=O)O- : ValenceFreeElectrons on =O = 6 - 2 = 6 - 2 - 0 - 0 = 4
1061
1062 GetX
1063 $X = $Atom->GetX();
1064
1065 Returns value of X-coordinate for an *Atom*.
1066
1067 GetXYZ
1068 @XYZ = $Atom->GetXYZ();
1069 $XYZRef = $Atom->GetXYZ();
1070
1071 Returns an array or a reference to an array containing values for
1072 *Atom* coordinates.
1073
1074 GetXYZVector
1075 $XYZVector = $Atom->GetXYZVector();
1076
1077 Returns a *Vector* object containing values for *Atom* coordinates
1078
1079 GetY
1080 $Y = $Atom->GetY();
1081
1082 Returns value of Y-coordinate for an *Atom*.
1083
1084 GetZ
1085 $Z = $Atom->GetZ();
1086
1087 Returns value of Z-coordinate for an *Atom*.
1088
1089 IsAmideCarbon
1090 $Status = $Atom->IsAmideCarbon();
1091
1092 Returns 1 or 0 based on whether it's amide carbon *Atom*.
1093
1094 An amide group is defineds as:
1095
1096 R-C(=O)-N(-R')-R''
1097
1098 where:
1099
1100 o R = Hydrogen or groups of atoms attached through carbon
1101 o R' = Hydrogens or groups of atoms attached through carbon or
1102 hetro atoms
1103 o R'' = Hydrogens or groups of atoms attached through carbon or
1104 hetro atoms
1105
1106 IsAmideNitrogen
1107 $Status = $Atom->IsAmideNitrogen();
1108
1109 Returns 1 or 0 based on whether it's amide nitrogen *Atom*.
1110
1111 IsAromatic
1112 $Status = $Atom->IsAromatic();
1113
1114 Returns 1 or 0 based on whether it's an aromatic *Atom*.
1115
1116 IsArsenic
1117 $Status = $Atom->IsArsenic();
1118
1119 Returns 1 or 0 based on whether it's an arsenic *Atom*.
1120
1121 IsBondedToAtom
1122 $Status = $Atom->IsBondedToAtom($OtherAtom);
1123
1124 Returns 1 or 0 based on whether *Atom* is bonded to *OtherAtom*.
1125
1126 IsBromine
1127 $Status = $Atom->IsBromine();
1128
1129 Returns 1 or 0 based on whether it's a bromine *Atom*.
1130
1131 IsCarbon
1132 $Status = $Atom->IsCarbon();
1133
1134 Returns 1 or 0 based on whether it's a carbon *Atom*.
1135
1136 IsCarboxylCarbon
1137 $Status = $Atom->IsCarboxylCarbon();
1138
1139 Returns 1 or 0 based on whether it's a carboxyl carbon atom in
1140 carboxyl group: R-C(=O)-OH.
1141
1142 IsCarboxylOxygen
1143 $Status = $Atom->IsCarboxylOxygen();
1144
1145 Returns 1 or 0 based on whether it's a carboxyl oxygen atom in
1146 carboxyl group: R-C(=O)-OH.
1147
1148 IsCarboxylateCarbon
1149 $Status = $Atom->IsCarboxylateCarbon();
1150
1151 Returns 1 or 0 based on whether it's a carboxylate carbon atom in
1152 carboxyl group: R-C(=O)-O-.
1153
1154 IsCarboxylateOxygen
1155 $Status = $Atom->IsCarboxylateOxygen();
1156
1157 Returns 1 or 0 based on whether it's a carboxylate oxygen atom in
1158 carboxyl group: R-C(=O)-O-.
1159
1160 IsChlorine
1161 $Status = $Atom->IsChlorine();
1162
1163 Returns 1 or 0 based on whether it's a chlorine *Atom*.
1164
1165 IsFluorine
1166 $Status = $Atom->IsFluorine();
1167
1168 Returns 1 or 0 based on whether it's a fluorine *Atom*.
1169
1170 IsFunctionalClassType
1171 $Status =$Atom->IsFunctionalClassType($Type);
1172
1173 Returns 1 or 0 based on whether it's a specified functional class
1174 *Type*.
1175
1176 The current release of MayaChemTools supports following
1177 abbreviations and descriptive names for *FunctionalClassType*:
1178
1179 HBD: HydrogenBondDonor
1180 HBA: HydrogenBondAcceptor
1181 PI : PositivelyIonizable
1182 NI : NegativelyIonizable
1183 Ar : Aromatic
1184 Hal : Halogen
1185 H : Hydrophobic
1186 RA : RingAtom
1187 CA : ChainAtom
1188
1189 The following definitions are used to determine functional class
1190 types: [ Ref 60-61, Ref 65-66 ]:
1191
1192 HydrogenBondDonor: NH, NH2, OH
1193 HydrogenBondAcceptor: N[!H], O
1194 PositivelyIonizable: +, NH2
1195 NegativelyIonizable: -, C(=O)OH, S(=O)OH, P(=O)OH
1196
1197 IsGuadiniumCarbon
1198 $Status = $Atom->IsGuadiniumCarbon();
1199
1200 Returns 1 or 0 based on whether it's a guadinium carbon in guadinium
1201 group by checking its neighbors for a nitrogen in guadinium group.
1202
1203 IsGuadiniumNitrogen
1204 $Status = $Atom->IsGuadiniumNitrogen();
1205
1206 Returns 1 or 0 based on whether it's a guadinium nitrogen in
1207 guadinium group.
1208
1209 A guadinium group is defined as:
1210
1211 R2N-C(=NR)-(NR2) or R2N-C(=NR2+)-(NR2)
1212
1213 where:
1214
1215 o R = Hydrogens or group of atoms attached through carbon
1216 o Only one of the three nitrogens has a double bond to carbon
1217 and has optional formal charge allowing it to be neutral or charged state
1218
1219 IsHBondAcceptor
1220 $Status =$Atom->IsHBondAcceptor();
1221 $Status =$Atom->IsHBondAcceptor($HydrogenBondsType);
1222
1223 Returns 1 or 0 based on whether it's a hydrogen bond acceptor
1224 *Atom*.
1225
1226 IsHBondDonor
1227 $Status =$Atom->IsHBondDonor();
1228 $Status =$Atom->IsHBondDonor($HydrogenBondsType);
1229
1230 Returns 1 or 0 based on whether it's a hydrogen bond donor *Atom*.
1231
1232 IsHydrogenBondAcceptor
1233 $Status =$Atom->IsHydrogenBondAcceptor();
1234 $Status =$Atom->IsHydrogenBondAcceptor($HydrogenBondsType);
1235
1236 Returns 1 or 0 based on whether it's a hydrogen bond acceptor
1237 *Atom*.
1238
1239 IsHydrogenBondDonor
1240 $Status =$Atom->IsHydrogenBondDonor();
1241 $Status =$Atom->IsHydrogenBondDonor($HydrogenBondsType);
1242
1243 Returns 1 or 0 based on whether it's a hydrogen bond donor *Atom*.
1244
1245 The current release of MayaChemTools supports identification of two
1246 types of hydrogen bond donor and acceptor atoms with these names:
1247
1248 HBondsType1 or HydrogenBondsType1
1249 HBondsType2 or HydrogenBondsType2
1250
1251 The names of these hydrogen bond types are rather arbitrary.
1252 However, their definitions have specific meaning and are as follows:
1253
1254 HydrogenBondsType1 [ Ref 60-61, Ref 65-66 ]:
1255
1256 Donor: NH, NH2, OH - Any N and O with available H
1257 Acceptor: N[!H], O - Any N without available H and any O
1258
1259 HydrogenBondsType2 [ Ref 91 ]:
1260
1261 Donor: NH, NH2, OH - N and O with available H
1262 Acceptor: N, O - And N and O
1263
1264 By default, *HydrogenBondsType1* is used to calculate number
1265 hydrogen bond donor and acceptor atoms. *HydrogenBondsType2*
1266 corresponds to RuleOf5 definition of hydrogen bond donors and
1267 acceptors.
1268
1269 IsHalogen
1270 $Status =$Atom->IsHalogen();
1271
1272 Returns 1 or 0 based on whether it's a halogen *Atom*.
1273
1274 IsHeteroAtom
1275 $Status = $Atom->IsHeteroAtom();
1276
1277 Returns 0 or 1 based on whether it's a hetro *Atom*. Following atoms
1278 are considered hetro atoms: N, O, F, P, S, Cl, Br, I.
1279
1280 IsHydrogen
1281 $Status = $Atom->IsHydrogen();
1282
1283 Returns 1 or 0 based on whether it's a hydrogen *Atom*.
1284
1285 IsHydrophobic
1286 $Status =$Atom->IsHydrophobic();
1287
1288 Returns 1 or 0 based on whether it's a hydrophobic *Atom*.
1289
1290 IsInRing
1291 $Status = $Atom->IsInRing();
1292
1293 Returns 1 or 0 based on whether *Atom* is present in a ring.
1294
1295 IsInRingOfSize
1296 $Status = $Atom->IsInRingOfSize($Size);
1297
1298 Returns 1 or 0 based on whether *Atom* is present in a ring of
1299 specific *Size*.
1300
1301 IsIodine
1302 $Status = $Atom->IsIodine();
1303
1304 Returns 1 or 0 based on whether it's an iodine *Atom*.
1305
1306 IsIsotope
1307 $Status =$Atom->IsIsotope();
1308
1309 Returns 1 or 0 based on whether it's an isotope *Atom*.
1310
1311 IsLipophilic
1312 $Status =$Atom->IsLipophilic();
1313
1314 Returns 1 or 0 based on whether it's a lipophilic *Atom*.
1315
1316 IsMetallic
1317 $Status = $Atom->IsMetallic();
1318
1319 Returns 1 or 0 based on whether it's a metallic *Atom*.
1320
1321 IsNegativelyIonizable
1322 $Status =$Atom->IsNegativelyIonizable();
1323
1324 Returns 1 or 0 based on whether it's a negatively ionizable atom
1325 *Atom*.
1326
1327 IsNitrogen
1328 $Status = $Atom->IsNitrogen();
1329
1330 Returns 1 or 0 based on whether it's a nitrogen *Atom*.
1331
1332 IsNonCarbonOrHydrogen
1333 $Status =$Atom->IsNonCarbonOrHydrogen();
1334
1335 Returns 1 or 0 based on whether it's not a carbon or hydrogen
1336 *Atom*.
1337
1338 IsNotInRing
1339 $Status = $Atom->IsNotInRing();
1340
1341 Returns 1 or 0 based on whether *Atom* is not present in a ring.
1342
1343 IsOnlyInOneRing
1344 $Status = $Atom->IsOnlyInOneRing();
1345
1346 Returns 1 or 0 based on whether *Atom* is only present in one ring.
1347
1348 IsOxygen
1349 $Status = $Atom->IsOxygen();
1350
1351 Returns 0 or 1 based on whether it's an oxygen *Atom*.
1352
1353 IsPhosphorus
1354 $Status = $Atom->IsPhosphorus();
1355
1356 Returns 0 or 1 based on whether it's a phosphorus *Atom*.
1357
1358 IsPhosphateOxygen
1359 $Status = $Atom->IsPhosphateOxygen();
1360
1361 Returns 1 or 0 based on whether it's a phosphate oxygen in phosphate
1362 group.
1363
1364 A phosphate group is defined as:
1365
1366 AO-(O=)P(-OA)-OA
1367
1368 Where:
1369
1370 A - Any group of atoms including hydrogens
1371
1372 IsPhosphatePhosphorus
1373 $Status = $Atom->IsPhosphatePhosphorus();
1374
1375 Returns 1 or 0 based on whether it's a phosphate phosphorus in
1376 phosphate group.
1377
1378 IsPolarAtom
1379 $Status = $Atom->IsPolarAtom();
1380
1381 Returns 0 or 1 based on whether it's a polar *Atom*. Following atoms
1382 are considered polar atoms: N, O, P, S.
1383
1384 IsPolarHydrogen
1385 $Status = $Atom->IsPolarHydrogen();
1386
1387 Returns 0 or 1 based on whether it's a hydrogen *Atom* bonded to a
1388 polar atom.
1389
1390 IsPositivelyIonizable
1391 $Status =$Atom->IsPositivelyIonizable();
1392
1393 Returns 1 or 0 based on whether it's a positively ionizable *Atom*.
1394
1395 IsSaturated
1396 $Status = $Atom->IsSaturated();
1397
1398 Returns 1 or 0 based on whether it's a saturated *Atom*. An atom
1399 attached to other atoms with only single bonds is considered a
1400 saturated atom.
1401
1402 IsSelenium
1403 $Status = $Atom->IsSelenium();
1404
1405 Returns 0 or 1 based on whether it's a selenium *Atom*.
1406
1407 IsStereoCenter
1408 $Status = $Atom->IsStereoCenter();
1409
1410 Returns 0 or 1 based on whether it's marked as a stero center *Atom*
1411 by explicit setting of *StereoCenter* atom propert to value of *1*.
1412
1413 IsSilicon
1414 $Status = $Atom->IsSilicon();
1415
1416 Returns 0 or 1 based on whether it's a silicon *Atom*.
1417
1418 IsSulfur
1419 $Status = $Atom->IsSulfur();
1420
1421 Returns 0 or 1 based on whether it's a sulfur *Atom*.
1422
1423 IsSulphur
1424 $Status = $Atom->IsSulphur();
1425
1426 Returns 0 or 1 based on whether it's a sulfur *Atom*.
1427
1428 IsTellurium
1429 $Status = $Atom->IsTellurium();
1430
1431 Returns 0 or 1 based on whether it's a tellurium *Atom*.
1432
1433 IsTerminal
1434 $Status = $Atom->IsTerminal();
1435
1436 Returns 0 or 1 based on whether it's a terminal *Atom* attached to
1437 no more than one non-hydrogen atom.
1438
1439 IsUnsaturated
1440 $Status = $Atom->IsUnsaturated();
1441
1442 Returns 1 or 0 based on whether it's as unsaturated *Atom*. An atom
1443 attached to other atoms with at least one non-single bond is
1444 considered an unsaturated atom.
1445
1446 IsTopologicalPharmacophoreType
1447 $Status =$Atom->IsTopologicalPharmacophoreType();
1448
1449 Returns 1 or 0 based on whether it's any of the supportyed
1450 topological pharmacophore *Atom* type. See *IsFunctionalClassType*
1451 for a list of supported types.
1452
1453 SetAtomSymbol
1454 $Atom->SetAtomSymbol($AtomicSymbol);
1455
1456 Sets atom symbol for *Atom* and returns *Atom* object. The
1457 appropriate atomic number is also set automatically.
1458
1459 SetAtomicNumber
1460 $Atom->SetAtomicNumber($AtomicNumber);
1461
1462 Sets atomic number for *Atom* and returns *Atom* object. The
1463 appropriate atom symbol is also set automatically.
1464
1465 SetMassNumber
1466 $Atom->SetMassNumber($MassNumber);
1467
1468 Sets mass number for *Atom* and returns *Atom* object.
1469
1470 SetStereoCenter
1471 $Atom->SetStereoCenter($StereoCenter);
1472
1473 Sets stereo center for *Atom* and returns *Atom* object.
1474
1475 SetStereochemistry
1476 $Atom->SetStereochemistry($Stereochemistry);
1477
1478 Sets stereo chemistry for *Atom* and returns *Atom* object.
1479
1480 SetX
1481 $Atom->SetX($Value);
1482
1483 Sets X-coordinate value for *Atom* and returns *Atom* object.
1484
1485 SetXYZ
1486 $Atom->SetXYZ(@XYZValues);
1487 $Atom->SetXYZ($XYZValuesRef);
1488 $Atom->SetXYZ($XYZVector);
1489
1490 Sets *Atom* coordinates using an array, reference to an array or a
1491 *Vector* object and returns *Atom* object.
1492
1493 SetY
1494 $Atom->SetY($Value);
1495
1496 Sets Y-coordinate value for *Atom* and returns *Atom* object.
1497
1498 SetZ
1499 $Atom->SetZ($Value);
1500
1501 Sets Z-coordinate value for *Atom* and returns *Atom* object.
1502
1503 StringifyAtom
1504 $AtomString = $Atom->StringifyAtom();
1505
1506 Returns a string containing information about *Atom* object.
1507
1508 AUTHOR
1509 Manish Sud <msud@san.rr.com>
1510
1511 SEE ALSO
1512 Bond.pm, Molecule.pm, MoleculeFileIO.pm
1513
1514 COPYRIGHT
1515 Copyright (C) 2015 Manish Sud. All rights reserved.
1516
1517 This file is part of MayaChemTools.
1518
1519 MayaChemTools is free software; you can redistribute it and/or modify it
1520 under the terms of the GNU Lesser General Public License as published by
1521 the Free Software Foundation; either version 3 of the License, or (at
1522 your option) any later version.
1523