Mercurial > repos > deepakjadmin > mayatool3_test2
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 |